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;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.ServiceWrapper;
020    
021    /**
022     * Provides a wrapper for {@link SCFrameworkVersionLocalService}.
023     *
024     * @author Brian Wing Shun Chan
025     * @see SCFrameworkVersionLocalService
026     * @generated
027     */
028    @ProviderType
029    public class SCFrameworkVersionLocalServiceWrapper
030            implements SCFrameworkVersionLocalService,
031                    ServiceWrapper<SCFrameworkVersionLocalService> {
032            public SCFrameworkVersionLocalServiceWrapper(
033                    SCFrameworkVersionLocalService scFrameworkVersionLocalService) {
034                    _scFrameworkVersionLocalService = scFrameworkVersionLocalService;
035            }
036    
037            @Override
038            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion addFrameworkVersion(
039                    long userId, java.lang.String name, java.lang.String url,
040                    boolean active, int priority,
041                    com.liferay.portal.service.ServiceContext serviceContext)
042                    throws com.liferay.portal.kernel.exception.PortalException {
043                    return _scFrameworkVersionLocalService.addFrameworkVersion(userId,
044                            name, url, active, priority, serviceContext);
045            }
046    
047            @Override
048            public void addFrameworkVersionResources(
049                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion frameworkVersion,
050                    boolean addGroupPermissions, boolean addGuestPermissions)
051                    throws com.liferay.portal.kernel.exception.PortalException {
052                    _scFrameworkVersionLocalService.addFrameworkVersionResources(frameworkVersion,
053                            addGroupPermissions, addGuestPermissions);
054            }
055    
056            @Override
057            public void addFrameworkVersionResources(
058                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion frameworkVersion,
059                    com.liferay.portal.service.permission.ModelPermissions modelPermissions)
060                    throws com.liferay.portal.kernel.exception.PortalException {
061                    _scFrameworkVersionLocalService.addFrameworkVersionResources(frameworkVersion,
062                            modelPermissions);
063            }
064    
065            @Override
066            public void addFrameworkVersionResources(long frameworkVersionId,
067                    boolean addGroupPermissions, boolean addGuestPermissions)
068                    throws com.liferay.portal.kernel.exception.PortalException {
069                    _scFrameworkVersionLocalService.addFrameworkVersionResources(frameworkVersionId,
070                            addGroupPermissions, addGuestPermissions);
071            }
072    
073            @Override
074            public void addFrameworkVersionResources(long frameworkVersionId,
075                    com.liferay.portal.service.permission.ModelPermissions modelPermissions)
076                    throws com.liferay.portal.kernel.exception.PortalException {
077                    _scFrameworkVersionLocalService.addFrameworkVersionResources(frameworkVersionId,
078                            modelPermissions);
079            }
080    
081            /**
082            * Adds the s c framework version to the database. Also notifies the appropriate model listeners.
083            *
084            * @param scFrameworkVersion the s c framework version
085            * @return the s c framework version that was added
086            */
087            @Override
088            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion addSCFrameworkVersion(
089                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
090                    return _scFrameworkVersionLocalService.addSCFrameworkVersion(scFrameworkVersion);
091            }
092    
093            @Override
094            public void addSCProductVersionSCFrameworkVersion(long productVersionId,
095                    long frameworkVersionId) {
096                    _scFrameworkVersionLocalService.addSCProductVersionSCFrameworkVersion(productVersionId,
097                            frameworkVersionId);
098            }
099    
100            @Override
101            public void addSCProductVersionSCFrameworkVersion(long productVersionId,
102                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
103                    _scFrameworkVersionLocalService.addSCProductVersionSCFrameworkVersion(productVersionId,
104                            scFrameworkVersion);
105            }
106    
107            @Override
108            public void addSCProductVersionSCFrameworkVersions(long productVersionId,
109                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> SCFrameworkVersions) {
110                    _scFrameworkVersionLocalService.addSCProductVersionSCFrameworkVersions(productVersionId,
111                            SCFrameworkVersions);
112            }
113    
114            @Override
115            public void addSCProductVersionSCFrameworkVersions(long productVersionId,
116                    long[] frameworkVersionIds) {
117                    _scFrameworkVersionLocalService.addSCProductVersionSCFrameworkVersions(productVersionId,
118                            frameworkVersionIds);
119            }
120    
121            @Override
122            public void clearSCProductVersionSCFrameworkVersions(long productVersionId) {
123                    _scFrameworkVersionLocalService.clearSCProductVersionSCFrameworkVersions(productVersionId);
124            }
125    
126            /**
127            * Creates a new s c framework version with the primary key. Does not add the s c framework version to the database.
128            *
129            * @param frameworkVersionId the primary key for the new s c framework version
130            * @return the new s c framework version
131            */
132            @Override
133            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion createSCFrameworkVersion(
134                    long frameworkVersionId) {
135                    return _scFrameworkVersionLocalService.createSCFrameworkVersion(frameworkVersionId);
136            }
137    
138            @Override
139            public void deleteFrameworkVersion(
140                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion frameworkVersion) {
141                    _scFrameworkVersionLocalService.deleteFrameworkVersion(frameworkVersion);
142            }
143    
144            @Override
145            public void deleteFrameworkVersion(long frameworkVersionId)
146                    throws com.liferay.portal.kernel.exception.PortalException {
147                    _scFrameworkVersionLocalService.deleteFrameworkVersion(frameworkVersionId);
148            }
149    
150            @Override
151            public void deleteFrameworkVersions(long groupId) {
152                    _scFrameworkVersionLocalService.deleteFrameworkVersions(groupId);
153            }
154    
155            /**
156            * @throws PortalException
157            */
158            @Override
159            public com.liferay.portal.model.PersistedModel deletePersistedModel(
160                    com.liferay.portal.model.PersistedModel persistedModel)
161                    throws com.liferay.portal.kernel.exception.PortalException {
162                    return _scFrameworkVersionLocalService.deletePersistedModel(persistedModel);
163            }
164    
165            /**
166            * Deletes the s c framework version with the primary key from the database. Also notifies the appropriate model listeners.
167            *
168            * @param frameworkVersionId the primary key of the s c framework version
169            * @return the s c framework version that was removed
170            * @throws PortalException if a s c framework version with the primary key could not be found
171            */
172            @Override
173            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion deleteSCFrameworkVersion(
174                    long frameworkVersionId)
175                    throws com.liferay.portal.kernel.exception.PortalException {
176                    return _scFrameworkVersionLocalService.deleteSCFrameworkVersion(frameworkVersionId);
177            }
178    
179            /**
180            * Deletes the s c framework version from the database. Also notifies the appropriate model listeners.
181            *
182            * @param scFrameworkVersion the s c framework version
183            * @return the s c framework version that was removed
184            */
185            @Override
186            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion deleteSCFrameworkVersion(
187                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
188                    return _scFrameworkVersionLocalService.deleteSCFrameworkVersion(scFrameworkVersion);
189            }
190    
191            @Override
192            public void deleteSCProductVersionSCFrameworkVersion(
193                    long productVersionId, long frameworkVersionId) {
194                    _scFrameworkVersionLocalService.deleteSCProductVersionSCFrameworkVersion(productVersionId,
195                            frameworkVersionId);
196            }
197    
198            @Override
199            public void deleteSCProductVersionSCFrameworkVersion(
200                    long productVersionId,
201                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
202                    _scFrameworkVersionLocalService.deleteSCProductVersionSCFrameworkVersion(productVersionId,
203                            scFrameworkVersion);
204            }
205    
206            @Override
207            public void deleteSCProductVersionSCFrameworkVersions(
208                    long productVersionId,
209                    java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> SCFrameworkVersions) {
210                    _scFrameworkVersionLocalService.deleteSCProductVersionSCFrameworkVersions(productVersionId,
211                            SCFrameworkVersions);
212            }
213    
214            @Override
215            public void deleteSCProductVersionSCFrameworkVersions(
216                    long productVersionId, long[] frameworkVersionIds) {
217                    _scFrameworkVersionLocalService.deleteSCProductVersionSCFrameworkVersions(productVersionId,
218                            frameworkVersionIds);
219            }
220    
221            @Override
222            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
223                    return _scFrameworkVersionLocalService.dynamicQuery();
224            }
225    
226            /**
227            * Performs a dynamic query on the database and returns the matching rows.
228            *
229            * @param dynamicQuery the dynamic query
230            * @return the matching rows
231            */
232            @Override
233            public <T> java.util.List<T> dynamicQuery(
234                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
235                    return _scFrameworkVersionLocalService.dynamicQuery(dynamicQuery);
236            }
237    
238            /**
239            * Performs a dynamic query on the database and returns a range of the matching rows.
240            *
241            * <p>
242            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.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.
243            * </p>
244            *
245            * @param dynamicQuery the dynamic query
246            * @param start the lower bound of the range of model instances
247            * @param end the upper bound of the range of model instances (not inclusive)
248            * @return the range of matching rows
249            */
250            @Override
251            public <T> java.util.List<T> dynamicQuery(
252                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
253                    int end) {
254                    return _scFrameworkVersionLocalService.dynamicQuery(dynamicQuery,
255                            start, end);
256            }
257    
258            /**
259            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
260            *
261            * <p>
262            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.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.
263            * </p>
264            *
265            * @param dynamicQuery the dynamic query
266            * @param start the lower bound of the range of model instances
267            * @param end the upper bound of the range of model instances (not inclusive)
268            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
269            * @return the ordered range of matching rows
270            */
271            @Override
272            public <T> java.util.List<T> dynamicQuery(
273                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
274                    int end,
275                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
276                    return _scFrameworkVersionLocalService.dynamicQuery(dynamicQuery,
277                            start, end, orderByComparator);
278            }
279    
280            /**
281            * Returns the number of rows matching the dynamic query.
282            *
283            * @param dynamicQuery the dynamic query
284            * @return the number of rows matching the dynamic query
285            */
286            @Override
287            public long dynamicQueryCount(
288                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
289                    return _scFrameworkVersionLocalService.dynamicQueryCount(dynamicQuery);
290            }
291    
292            /**
293            * Returns the number of rows matching the dynamic query.
294            *
295            * @param dynamicQuery the dynamic query
296            * @param projection the projection to apply to the query
297            * @return the number of rows matching the dynamic query
298            */
299            @Override
300            public long dynamicQueryCount(
301                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
302                    com.liferay.portal.kernel.dao.orm.Projection projection) {
303                    return _scFrameworkVersionLocalService.dynamicQueryCount(dynamicQuery,
304                            projection);
305            }
306    
307            @Override
308            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion fetchSCFrameworkVersion(
309                    long frameworkVersionId) {
310                    return _scFrameworkVersionLocalService.fetchSCFrameworkVersion(frameworkVersionId);
311            }
312    
313            @Override
314            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
315                    return _scFrameworkVersionLocalService.getActionableDynamicQuery();
316            }
317    
318            /**
319            * Returns the Spring bean ID for this bean.
320            *
321            * @return the Spring bean ID for this bean
322            */
323            @Override
324            public java.lang.String getBeanIdentifier() {
325                    return _scFrameworkVersionLocalService.getBeanIdentifier();
326            }
327    
328            @Override
329            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion getFrameworkVersion(
330                    long frameworkVersionId)
331                    throws com.liferay.portal.kernel.exception.PortalException {
332                    return _scFrameworkVersionLocalService.getFrameworkVersion(frameworkVersionId);
333            }
334    
335            @Override
336            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getFrameworkVersions(
337                    long groupId, boolean active) {
338                    return _scFrameworkVersionLocalService.getFrameworkVersions(groupId,
339                            active);
340            }
341    
342            @Override
343            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getFrameworkVersions(
344                    long groupId, boolean active, int start, int end) {
345                    return _scFrameworkVersionLocalService.getFrameworkVersions(groupId,
346                            active, start, end);
347            }
348    
349            @Override
350            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getFrameworkVersions(
351                    long groupId, int start, int end) {
352                    return _scFrameworkVersionLocalService.getFrameworkVersions(groupId,
353                            start, end);
354            }
355    
356            @Override
357            public int getFrameworkVersionsCount(long groupId) {
358                    return _scFrameworkVersionLocalService.getFrameworkVersionsCount(groupId);
359            }
360    
361            @Override
362            public int getFrameworkVersionsCount(long groupId, boolean active) {
363                    return _scFrameworkVersionLocalService.getFrameworkVersionsCount(groupId,
364                            active);
365            }
366    
367            @Override
368            public com.liferay.portal.model.PersistedModel getPersistedModel(
369                    java.io.Serializable primaryKeyObj)
370                    throws com.liferay.portal.kernel.exception.PortalException {
371                    return _scFrameworkVersionLocalService.getPersistedModel(primaryKeyObj);
372            }
373    
374            @Override
375            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getProductVersionFrameworkVersions(
376                    long productVersionId) {
377                    return _scFrameworkVersionLocalService.getProductVersionFrameworkVersions(productVersionId);
378            }
379    
380            /**
381            * Returns the s c framework version with the primary key.
382            *
383            * @param frameworkVersionId the primary key of the s c framework version
384            * @return the s c framework version
385            * @throws PortalException if a s c framework version with the primary key could not be found
386            */
387            @Override
388            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion getSCFrameworkVersion(
389                    long frameworkVersionId)
390                    throws com.liferay.portal.kernel.exception.PortalException {
391                    return _scFrameworkVersionLocalService.getSCFrameworkVersion(frameworkVersionId);
392            }
393    
394            /**
395            * Returns a range of all the s c framework versions.
396            *
397            * <p>
398            * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.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.
399            * </p>
400            *
401            * @param start the lower bound of the range of s c framework versions
402            * @param end the upper bound of the range of s c framework versions (not inclusive)
403            * @return the range of s c framework versions
404            */
405            @Override
406            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCFrameworkVersions(
407                    int start, int end) {
408                    return _scFrameworkVersionLocalService.getSCFrameworkVersions(start, end);
409            }
410    
411            /**
412            * Returns the number of s c framework versions.
413            *
414            * @return the number of s c framework versions
415            */
416            @Override
417            public int getSCFrameworkVersionsCount() {
418                    return _scFrameworkVersionLocalService.getSCFrameworkVersionsCount();
419            }
420    
421            /**
422            * Returns the productVersionIds of the s c product versions associated with the s c framework version.
423            *
424            * @param frameworkVersionId the frameworkVersionId of the s c framework version
425            * @return long[] the productVersionIds of s c product versions associated with the s c framework version
426            */
427            @Override
428            public long[] getSCProductVersionPrimaryKeys(long frameworkVersionId) {
429                    return _scFrameworkVersionLocalService.getSCProductVersionPrimaryKeys(frameworkVersionId);
430            }
431    
432            @Override
433            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCProductVersionSCFrameworkVersions(
434                    long productVersionId) {
435                    return _scFrameworkVersionLocalService.getSCProductVersionSCFrameworkVersions(productVersionId);
436            }
437    
438            @Override
439            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCProductVersionSCFrameworkVersions(
440                    long productVersionId, int start, int end) {
441                    return _scFrameworkVersionLocalService.getSCProductVersionSCFrameworkVersions(productVersionId,
442                            start, end);
443            }
444    
445            @Override
446            public java.util.List<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> getSCProductVersionSCFrameworkVersions(
447                    long productVersionId, int start, int end,
448                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion> orderByComparator) {
449                    return _scFrameworkVersionLocalService.getSCProductVersionSCFrameworkVersions(productVersionId,
450                            start, end, orderByComparator);
451            }
452    
453            @Override
454            public int getSCProductVersionSCFrameworkVersionsCount(
455                    long productVersionId) {
456                    return _scFrameworkVersionLocalService.getSCProductVersionSCFrameworkVersionsCount(productVersionId);
457            }
458    
459            @Override
460            public boolean hasSCProductVersionSCFrameworkVersion(
461                    long productVersionId, long frameworkVersionId) {
462                    return _scFrameworkVersionLocalService.hasSCProductVersionSCFrameworkVersion(productVersionId,
463                            frameworkVersionId);
464            }
465    
466            @Override
467            public boolean hasSCProductVersionSCFrameworkVersions(long productVersionId) {
468                    return _scFrameworkVersionLocalService.hasSCProductVersionSCFrameworkVersions(productVersionId);
469            }
470    
471            /**
472            * Sets the Spring bean ID for this bean.
473            *
474            * @param beanIdentifier the Spring bean ID for this bean
475            */
476            @Override
477            public void setBeanIdentifier(java.lang.String beanIdentifier) {
478                    _scFrameworkVersionLocalService.setBeanIdentifier(beanIdentifier);
479            }
480    
481            @Override
482            public void setSCProductVersionSCFrameworkVersions(long productVersionId,
483                    long[] frameworkVersionIds) {
484                    _scFrameworkVersionLocalService.setSCProductVersionSCFrameworkVersions(productVersionId,
485                            frameworkVersionIds);
486            }
487    
488            @Override
489            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion updateFrameworkVersion(
490                    long frameworkVersionId, java.lang.String name, java.lang.String url,
491                    boolean active, int priority)
492                    throws com.liferay.portal.kernel.exception.PortalException {
493                    return _scFrameworkVersionLocalService.updateFrameworkVersion(frameworkVersionId,
494                            name, url, active, priority);
495            }
496    
497            /**
498            * Updates the s c framework version in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
499            *
500            * @param scFrameworkVersion the s c framework version
501            * @return the s c framework version that was updated
502            */
503            @Override
504            public com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion updateSCFrameworkVersion(
505                    com.liferay.portlet.softwarecatalog.model.SCFrameworkVersion scFrameworkVersion) {
506                    return _scFrameworkVersionLocalService.updateSCFrameworkVersion(scFrameworkVersion);
507            }
508    
509            /**
510             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
511             */
512            @Deprecated
513            public SCFrameworkVersionLocalService getWrappedSCFrameworkVersionLocalService() {
514                    return _scFrameworkVersionLocalService;
515            }
516    
517            /**
518             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
519             */
520            @Deprecated
521            public void setWrappedSCFrameworkVersionLocalService(
522                    SCFrameworkVersionLocalService scFrameworkVersionLocalService) {
523                    _scFrameworkVersionLocalService = scFrameworkVersionLocalService;
524            }
525    
526            @Override
527            public SCFrameworkVersionLocalService getWrappedService() {
528                    return _scFrameworkVersionLocalService;
529            }
530    
531            @Override
532            public void setWrappedService(
533                    SCFrameworkVersionLocalService scFrameworkVersionLocalService) {
534                    _scFrameworkVersionLocalService = scFrameworkVersionLocalService;
535            }
536    
537            private SCFrameworkVersionLocalService _scFrameworkVersionLocalService;
538    }