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.SCProductVersion; 022 023 /** 024 * The persistence interface for the s c product version 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.SCProductVersionPersistenceImpl 032 * @see SCProductVersionUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface SCProductVersionPersistence extends BasePersistence<SCProductVersion> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link SCProductVersionUtil} to access the s c product version persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the s c product versions where productEntryId = ?. 045 * 046 * @param productEntryId the product entry ID 047 * @return the matching s c product versions 048 */ 049 public java.util.List<SCProductVersion> findByProductEntryId( 050 long productEntryId); 051 052 /** 053 * Returns a range of all the s c product versions where productEntryId = ?. 054 * 055 * <p> 056 * 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 SCProductVersionModelImpl}. 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. 057 * </p> 058 * 059 * @param productEntryId the product entry ID 060 * @param start the lower bound of the range of s c product versions 061 * @param end the upper bound of the range of s c product versions (not inclusive) 062 * @return the range of matching s c product versions 063 */ 064 public java.util.List<SCProductVersion> findByProductEntryId( 065 long productEntryId, int start, int end); 066 067 /** 068 * Returns an ordered range of all the s c product versions where productEntryId = ?. 069 * 070 * <p> 071 * 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 SCProductVersionModelImpl}. 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. 072 * </p> 073 * 074 * @param productEntryId the product entry ID 075 * @param start the lower bound of the range of s c product versions 076 * @param end the upper bound of the range of s c product versions (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching s c product versions 079 */ 080 public java.util.List<SCProductVersion> findByProductEntryId( 081 long productEntryId, int start, int end, 082 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 083 084 /** 085 * Returns an ordered range of all the s c product versions where productEntryId = ?. 086 * 087 * <p> 088 * 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 SCProductVersionModelImpl}. 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. 089 * </p> 090 * 091 * @param productEntryId the product entry ID 092 * @param start the lower bound of the range of s c product versions 093 * @param end the upper bound of the range of s c product versions (not inclusive) 094 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 095 * @param retrieveFromCache whether to retrieve from the finder cache 096 * @return the ordered range of matching s c product versions 097 */ 098 public java.util.List<SCProductVersion> findByProductEntryId( 099 long productEntryId, int start, int end, 100 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator, 101 boolean retrieveFromCache); 102 103 /** 104 * Returns the first s c product version in the ordered set where productEntryId = ?. 105 * 106 * @param productEntryId the product entry ID 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the first matching s c product version 109 * @throws NoSuchProductVersionException if a matching s c product version could not be found 110 */ 111 public SCProductVersion findByProductEntryId_First(long productEntryId, 112 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator) 113 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 114 115 /** 116 * Returns the first s c product version in the ordered set where productEntryId = ?. 117 * 118 * @param productEntryId the product entry ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the first matching s c product version, or <code>null</code> if a matching s c product version could not be found 121 */ 122 public SCProductVersion fetchByProductEntryId_First(long productEntryId, 123 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 124 125 /** 126 * Returns the last s c product version in the ordered set where productEntryId = ?. 127 * 128 * @param productEntryId the product entry ID 129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 130 * @return the last matching s c product version 131 * @throws NoSuchProductVersionException if a matching s c product version could not be found 132 */ 133 public SCProductVersion findByProductEntryId_Last(long productEntryId, 134 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator) 135 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 136 137 /** 138 * Returns the last s c product version in the ordered set where productEntryId = ?. 139 * 140 * @param productEntryId the product entry ID 141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 142 * @return the last matching s c product version, or <code>null</code> if a matching s c product version could not be found 143 */ 144 public SCProductVersion fetchByProductEntryId_Last(long productEntryId, 145 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 146 147 /** 148 * Returns the s c product versions before and after the current s c product version in the ordered set where productEntryId = ?. 149 * 150 * @param productVersionId the primary key of the current s c product version 151 * @param productEntryId the product entry ID 152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 153 * @return the previous, current, and next s c product version 154 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 155 */ 156 public SCProductVersion[] findByProductEntryId_PrevAndNext( 157 long productVersionId, long productEntryId, 158 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator) 159 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 160 161 /** 162 * Removes all the s c product versions where productEntryId = ? from the database. 163 * 164 * @param productEntryId the product entry ID 165 */ 166 public void removeByProductEntryId(long productEntryId); 167 168 /** 169 * Returns the number of s c product versions where productEntryId = ?. 170 * 171 * @param productEntryId the product entry ID 172 * @return the number of matching s c product versions 173 */ 174 public int countByProductEntryId(long productEntryId); 175 176 /** 177 * Returns the s c product version where directDownloadURL = ? or throws a {@link NoSuchProductVersionException} if it could not be found. 178 * 179 * @param directDownloadURL the direct download u r l 180 * @return the matching s c product version 181 * @throws NoSuchProductVersionException if a matching s c product version could not be found 182 */ 183 public SCProductVersion findByDirectDownloadURL( 184 java.lang.String directDownloadURL) 185 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 186 187 /** 188 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 189 * 190 * @param directDownloadURL the direct download u r l 191 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 192 */ 193 public SCProductVersion fetchByDirectDownloadURL( 194 java.lang.String directDownloadURL); 195 196 /** 197 * Returns the s c product version where directDownloadURL = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 198 * 199 * @param directDownloadURL the direct download u r l 200 * @param retrieveFromCache whether to retrieve from the finder cache 201 * @return the matching s c product version, or <code>null</code> if a matching s c product version could not be found 202 */ 203 public SCProductVersion fetchByDirectDownloadURL( 204 java.lang.String directDownloadURL, boolean retrieveFromCache); 205 206 /** 207 * Removes the s c product version where directDownloadURL = ? from the database. 208 * 209 * @param directDownloadURL the direct download u r l 210 * @return the s c product version that was removed 211 */ 212 public SCProductVersion removeByDirectDownloadURL( 213 java.lang.String directDownloadURL) 214 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 215 216 /** 217 * Returns the number of s c product versions where directDownloadURL = ?. 218 * 219 * @param directDownloadURL the direct download u r l 220 * @return the number of matching s c product versions 221 */ 222 public int countByDirectDownloadURL(java.lang.String directDownloadURL); 223 224 /** 225 * Caches the s c product version in the entity cache if it is enabled. 226 * 227 * @param scProductVersion the s c product version 228 */ 229 public void cacheResult(SCProductVersion scProductVersion); 230 231 /** 232 * Caches the s c product versions in the entity cache if it is enabled. 233 * 234 * @param scProductVersions the s c product versions 235 */ 236 public void cacheResult(java.util.List<SCProductVersion> scProductVersions); 237 238 /** 239 * Creates a new s c product version with the primary key. Does not add the s c product version to the database. 240 * 241 * @param productVersionId the primary key for the new s c product version 242 * @return the new s c product version 243 */ 244 public SCProductVersion create(long productVersionId); 245 246 /** 247 * Removes the s c product version with the primary key from the database. Also notifies the appropriate model listeners. 248 * 249 * @param productVersionId the primary key of the s c product version 250 * @return the s c product version that was removed 251 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 252 */ 253 public SCProductVersion remove(long productVersionId) 254 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 255 256 public SCProductVersion updateImpl(SCProductVersion scProductVersion); 257 258 /** 259 * Returns the s c product version with the primary key or throws a {@link NoSuchProductVersionException} if it could not be found. 260 * 261 * @param productVersionId the primary key of the s c product version 262 * @return the s c product version 263 * @throws NoSuchProductVersionException if a s c product version with the primary key could not be found 264 */ 265 public SCProductVersion findByPrimaryKey(long productVersionId) 266 throws com.liferay.portlet.softwarecatalog.NoSuchProductVersionException; 267 268 /** 269 * Returns the s c product version with the primary key or returns <code>null</code> if it could not be found. 270 * 271 * @param productVersionId the primary key of the s c product version 272 * @return the s c product version, or <code>null</code> if a s c product version with the primary key could not be found 273 */ 274 public SCProductVersion fetchByPrimaryKey(long productVersionId); 275 276 @Override 277 public java.util.Map<java.io.Serializable, SCProductVersion> fetchByPrimaryKeys( 278 java.util.Set<java.io.Serializable> primaryKeys); 279 280 /** 281 * Returns all the s c product versions. 282 * 283 * @return the s c product versions 284 */ 285 public java.util.List<SCProductVersion> findAll(); 286 287 /** 288 * Returns a range of all the s c product versions. 289 * 290 * <p> 291 * 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 SCProductVersionModelImpl}. 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. 292 * </p> 293 * 294 * @param start the lower bound of the range of s c product versions 295 * @param end the upper bound of the range of s c product versions (not inclusive) 296 * @return the range of s c product versions 297 */ 298 public java.util.List<SCProductVersion> findAll(int start, int end); 299 300 /** 301 * Returns an ordered range of all the s c product versions. 302 * 303 * <p> 304 * 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 SCProductVersionModelImpl}. 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. 305 * </p> 306 * 307 * @param start the lower bound of the range of s c product versions 308 * @param end the upper bound of the range of s c product versions (not inclusive) 309 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 310 * @return the ordered range of s c product versions 311 */ 312 public java.util.List<SCProductVersion> findAll(int start, int end, 313 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator); 314 315 /** 316 * Returns an ordered range of all the s c product versions. 317 * 318 * <p> 319 * 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 SCProductVersionModelImpl}. 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. 320 * </p> 321 * 322 * @param start the lower bound of the range of s c product versions 323 * @param end the upper bound of the range of s c product versions (not inclusive) 324 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 325 * @param retrieveFromCache whether to retrieve from the finder cache 326 * @return the ordered range of s c product versions 327 */ 328 public java.util.List<SCProductVersion> findAll(int start, int end, 329 com.liferay.portal.kernel.util.OrderByComparator<SCProductVersion> orderByComparator, 330 boolean retrieveFromCache); 331 332 /** 333 * Removes all the s c product versions from the database. 334 */ 335 public void removeAll(); 336 337 /** 338 * Returns the number of s c product versions. 339 * 340 * @return the number of s c product versions 341 */ 342 public int countAll(); 343 344 /** 345 * Returns the primaryKeys of s c framework versions associated with the s c product version. 346 * 347 * @param pk the primary key of the s c product version 348 * @return long[] of the primaryKeys of s c framework versions associated with the s c product version 349 */ 350 public long[] getSCFrameworkVersionPrimaryKeys(long pk); 351 352 /** 353 * Returns all the s c framework versions associated with the s c product version. 354 * 355 * @param pk the primary key of the s c product version 356 * @return the s c framework versions associated with the s c product version 357 */ 358 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 359 long pk); 360 361 /** 362 * Returns a range of all the s c framework versions associated with the s c product version. 363 * 364 * <p> 365 * 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 SCProductVersionModelImpl}. 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. 366 * </p> 367 * 368 * @param pk the primary key of the s c product version 369 * @param start the lower bound of the range of s c product versions 370 * @param end the upper bound of the range of s c product versions (not inclusive) 371 * @return the range of s c framework versions associated with the s c product version 372 */ 373 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 374 long pk, int start, int end); 375 376 /** 377 * Returns an ordered range of all the s c framework versions associated with the s c product version. 378 * 379 * <p> 380 * 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 SCProductVersionModelImpl}. 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. 381 * </p> 382 * 383 * @param pk the primary key of the s c product version 384 * @param start the lower bound of the range of s c product versions 385 * @param end the upper bound of the range of s c product versions (not inclusive) 386 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 387 * @return the ordered range of s c framework versions associated with the s c product version 388 */ 389 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions( 390 long pk, int start, int end, 391 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> orderByComparator); 392 393 /** 394 * Returns the number of s c framework versions associated with the s c product version. 395 * 396 * @param pk the primary key of the s c product version 397 * @return the number of s c framework versions associated with the s c product version 398 */ 399 public int getSCFrameworkVersionsSize(long pk); 400 401 /** 402 * Returns <code>true</code> if the s c framework version is associated with the s c product version. 403 * 404 * @param pk the primary key of the s c product version 405 * @param scFrameworkVersionPK the primary key of the s c framework version 406 * @return <code>true</code> if the s c framework version is associated with the s c product version; <code>false</code> otherwise 407 */ 408 public boolean containsSCFrameworkVersion(long pk, long scFrameworkVersionPK); 409 410 /** 411 * Returns <code>true</code> if the s c product version has any s c framework versions associated with it. 412 * 413 * @param pk the primary key of the s c product version to check for associations with s c framework versions 414 * @return <code>true</code> if the s c product version has any s c framework versions associated with it; <code>false</code> otherwise 415 */ 416 public boolean containsSCFrameworkVersions(long pk); 417 418 /** 419 * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 420 * 421 * @param pk the primary key of the s c product version 422 * @param scFrameworkVersionPK the primary key of the s c framework version 423 */ 424 public void addSCFrameworkVersion(long pk, long scFrameworkVersionPK); 425 426 /** 427 * Adds an association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 428 * 429 * @param pk the primary key of the s c product version 430 * @param scFrameworkVersion the s c framework version 431 */ 432 public void addSCFrameworkVersion(long pk, 433 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion); 434 435 /** 436 * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 437 * 438 * @param pk the primary key of the s c product version 439 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 440 */ 441 public void addSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs); 442 443 /** 444 * Adds an association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 445 * 446 * @param pk the primary key of the s c product version 447 * @param scFrameworkVersions the s c framework versions 448 */ 449 public void addSCFrameworkVersions(long pk, 450 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 451 452 /** 453 * Clears all associations between the s c product version and its s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 454 * 455 * @param pk the primary key of the s c product version to clear the associated s c framework versions from 456 */ 457 public void clearSCFrameworkVersions(long pk); 458 459 /** 460 * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 461 * 462 * @param pk the primary key of the s c product version 463 * @param scFrameworkVersionPK the primary key of the s c framework version 464 */ 465 public void removeSCFrameworkVersion(long pk, long scFrameworkVersionPK); 466 467 /** 468 * Removes the association between the s c product version and the s c framework version. Also notifies the appropriate model listeners and clears the mapping table finder cache. 469 * 470 * @param pk the primary key of the s c product version 471 * @param scFrameworkVersion the s c framework version 472 */ 473 public void removeSCFrameworkVersion(long pk, 474 com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion); 475 476 /** 477 * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 478 * 479 * @param pk the primary key of the s c product version 480 * @param scFrameworkVersionPKs the primary keys of the s c framework versions 481 */ 482 public void removeSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs); 483 484 /** 485 * Removes the association between the s c product version and the s c framework versions. Also notifies the appropriate model listeners and clears the mapping table finder cache. 486 * 487 * @param pk the primary key of the s c product version 488 * @param scFrameworkVersions the s c framework versions 489 */ 490 public void removeSCFrameworkVersions(long pk, 491 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 492 493 /** 494 * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 495 * 496 * @param pk the primary key of the s c product version 497 * @param scFrameworkVersionPKs the primary keys of the s c framework versions to be associated with the s c product version 498 */ 499 public void setSCFrameworkVersions(long pk, long[] scFrameworkVersionPKs); 500 501 /** 502 * Sets the s c framework versions associated with the s c product version, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 503 * 504 * @param pk the primary key of the s c product version 505 * @param scFrameworkVersions the s c framework versions to be associated with the s c product version 506 */ 507 public void setSCFrameworkVersions(long pk, 508 java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> scFrameworkVersions); 509 }