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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63;.
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 = &#63; 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 = &#63;.
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 = &#63; 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 = &#63; 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 = &#63; 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 = &#63; 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 = &#63;.
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    }