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