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.portal.service;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    /**
020     * Provides a wrapper for {@link RoleLocalService}.
021     *
022     * @author Brian Wing Shun Chan
023     * @see RoleLocalService
024     * @generated
025     */
026    @ProviderType
027    public class RoleLocalServiceWrapper implements RoleLocalService,
028            ServiceWrapper<RoleLocalService> {
029            public RoleLocalServiceWrapper(RoleLocalService roleLocalService) {
030                    _roleLocalService = roleLocalService;
031            }
032    
033            @Override
034            public void addGroupRole(long groupId, com.liferay.portal.model.Role role) {
035                    _roleLocalService.addGroupRole(groupId, role);
036            }
037    
038            @Override
039            public void addGroupRole(long groupId, long roleId) {
040                    _roleLocalService.addGroupRole(groupId, roleId);
041            }
042    
043            @Override
044            public void addGroupRoles(long groupId,
045                    java.util.List<com.liferay.portal.model.Role> Roles) {
046                    _roleLocalService.addGroupRoles(groupId, Roles);
047            }
048    
049            @Override
050            public void addGroupRoles(long groupId, long[] roleIds) {
051                    _roleLocalService.addGroupRoles(groupId, roleIds);
052            }
053    
054            /**
055            * Adds the role to the database. Also notifies the appropriate model listeners.
056            *
057            * @param role the role
058            * @return the role that was added
059            */
060            @Override
061            public com.liferay.portal.model.Role addRole(
062                    com.liferay.portal.model.Role role) {
063                    return _roleLocalService.addRole(role);
064            }
065    
066            /**
067            * Adds a role with additional parameters. The user is reindexed after role
068            * is added.
069            *
070            * @param userId the primary key of the user
071            * @param className the name of the class for which the role is created
072            (optionally <code>null</code>)
073            * @param classPK the primary key of the class for which the role is
074            created (optionally <code>0</code>)
075            * @param name the role's name
076            * @param titleMap the role's localized titles (optionally
077            <code>null</code>)
078            * @param descriptionMap the role's localized descriptions (optionally
079            <code>null</code>)
080            * @param type the role's type (optionally <code>0</code>)
081            * @param subtype the role's subtype (optionally <code>null</code>)
082            * @param serviceContext the service context to be applied (optionally
083            <code>null</code>). Can set expando bridge attributes for the
084            role.
085            * @return the role
086            */
087            @Override
088            public com.liferay.portal.model.Role addRole(long userId,
089                    java.lang.String className, long classPK, java.lang.String name,
090                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
091                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
092                    int type, java.lang.String subtype,
093                    com.liferay.portal.service.ServiceContext serviceContext)
094                    throws com.liferay.portal.kernel.exception.PortalException {
095                    return _roleLocalService.addRole(userId, className, classPK, name,
096                            titleMap, descriptionMap, type, subtype, serviceContext);
097            }
098    
099            /**
100            * Adds a role. The user is reindexed after role is added.
101            *
102            * @param userId the primary key of the user
103            * @param companyId the primary key of the company
104            * @param name the role's name
105            * @param titleMap the role's localized titles (optionally
106            <code>null</code>)
107            * @param descriptionMap the role's localized descriptions (optionally
108            <code>null</code>)
109            * @param type the role's type (optionally <code>0</code>)
110            * @return the role
111            * @deprecated As of 6.2.0, replaced by {@link #addRole(long, String, long,
112            String, Map, Map, int, String, ServiceContext)}
113            */
114            @Deprecated
115            @Override
116            public com.liferay.portal.model.Role addRole(long userId, long companyId,
117                    java.lang.String name,
118                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
119                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
120                    int type) throws com.liferay.portal.kernel.exception.PortalException {
121                    return _roleLocalService.addRole(userId, companyId, name, titleMap,
122                            descriptionMap, type);
123            }
124    
125            /**
126            * Adds a role with additional parameters. The user is reindexed after role
127            * is added.
128            *
129            * @param userId the primary key of the user
130            * @param companyId the primary key of the company
131            * @param name the role's name
132            * @param titleMap the role's localized titles (optionally
133            <code>null</code>)
134            * @param descriptionMap the role's localized descriptions (optionally
135            <code>null</code>)
136            * @param type the role's type (optionally <code>0</code>)
137            * @param className the name of the class for which the role is created
138            (optionally <code>null</code>)
139            * @param classPK the primary key of the class for which the role is
140            created (optionally <code>0</code>)
141            * @return the role
142            * @deprecated As of 6.2.0, replaced by {@link #addRole(long, String, long,
143            String, Map, Map, int, String, ServiceContext)}
144            */
145            @Deprecated
146            @Override
147            public com.liferay.portal.model.Role addRole(long userId, long companyId,
148                    java.lang.String name,
149                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
150                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
151                    int type, java.lang.String className, long classPK)
152                    throws com.liferay.portal.kernel.exception.PortalException {
153                    return _roleLocalService.addRole(userId, companyId, name, titleMap,
154                            descriptionMap, type, className, classPK);
155            }
156    
157            @Override
158            public void addUserRole(long userId, com.liferay.portal.model.Role role) {
159                    _roleLocalService.addUserRole(userId, role);
160            }
161    
162            @Override
163            public void addUserRole(long userId, long roleId) {
164                    _roleLocalService.addUserRole(userId, roleId);
165            }
166    
167            /**
168            * @throws PortalException
169            */
170            @Override
171            public void addUserRoles(long userId,
172                    java.util.List<com.liferay.portal.model.Role> Roles)
173                    throws com.liferay.portal.kernel.exception.PortalException {
174                    _roleLocalService.addUserRoles(userId, Roles);
175            }
176    
177            /**
178            * @throws PortalException
179            */
180            @Override
181            public void addUserRoles(long userId, long[] roleIds)
182                    throws com.liferay.portal.kernel.exception.PortalException {
183                    _roleLocalService.addUserRoles(userId, roleIds);
184            }
185    
186            /**
187            * Checks to ensure that the system roles map has appropriate default roles
188            * in each company.
189            */
190            @Override
191            public void checkSystemRoles()
192                    throws com.liferay.portal.kernel.exception.PortalException {
193                    _roleLocalService.checkSystemRoles();
194            }
195    
196            /**
197            * Checks to ensure that the system roles map has appropriate default roles
198            * in the company.
199            *
200            * @param companyId the primary key of the company
201            */
202            @Override
203            public void checkSystemRoles(long companyId)
204                    throws com.liferay.portal.kernel.exception.PortalException {
205                    _roleLocalService.checkSystemRoles(companyId);
206            }
207    
208            @Override
209            public void clearGroupRoles(long groupId) {
210                    _roleLocalService.clearGroupRoles(groupId);
211            }
212    
213            @Override
214            public void clearUserRoles(long userId) {
215                    _roleLocalService.clearUserRoles(userId);
216            }
217    
218            /**
219            * Creates a new role with the primary key. Does not add the role to the database.
220            *
221            * @param roleId the primary key for the new role
222            * @return the new role
223            */
224            @Override
225            public com.liferay.portal.model.Role createRole(long roleId) {
226                    return _roleLocalService.createRole(roleId);
227            }
228    
229            @Override
230            public void deleteGroupRole(long groupId, com.liferay.portal.model.Role role) {
231                    _roleLocalService.deleteGroupRole(groupId, role);
232            }
233    
234            @Override
235            public void deleteGroupRole(long groupId, long roleId) {
236                    _roleLocalService.deleteGroupRole(groupId, roleId);
237            }
238    
239            @Override
240            public void deleteGroupRoles(long groupId,
241                    java.util.List<com.liferay.portal.model.Role> Roles) {
242                    _roleLocalService.deleteGroupRoles(groupId, Roles);
243            }
244    
245            @Override
246            public void deleteGroupRoles(long groupId, long[] roleIds) {
247                    _roleLocalService.deleteGroupRoles(groupId, roleIds);
248            }
249    
250            /**
251            * @throws PortalException
252            */
253            @Override
254            public com.liferay.portal.model.PersistedModel deletePersistedModel(
255                    com.liferay.portal.model.PersistedModel persistedModel)
256                    throws com.liferay.portal.kernel.exception.PortalException {
257                    return _roleLocalService.deletePersistedModel(persistedModel);
258            }
259    
260            /**
261            * Deletes the role from the database. Also notifies the appropriate model listeners.
262            *
263            * @param role the role
264            * @return the role that was removed
265            * @throws PortalException
266            */
267            @Override
268            public com.liferay.portal.model.Role deleteRole(
269                    com.liferay.portal.model.Role role)
270                    throws com.liferay.portal.kernel.exception.PortalException {
271                    return _roleLocalService.deleteRole(role);
272            }
273    
274            /**
275            * Deletes the role with the primary key from the database. Also notifies the appropriate model listeners.
276            *
277            * @param roleId the primary key of the role
278            * @return the role that was removed
279            * @throws PortalException if a role with the primary key could not be found
280            */
281            @Override
282            public com.liferay.portal.model.Role deleteRole(long roleId)
283                    throws com.liferay.portal.kernel.exception.PortalException {
284                    return _roleLocalService.deleteRole(roleId);
285            }
286    
287            @Override
288            public void deleteUserRole(long userId, com.liferay.portal.model.Role role) {
289                    _roleLocalService.deleteUserRole(userId, role);
290            }
291    
292            @Override
293            public void deleteUserRole(long userId, long roleId) {
294                    _roleLocalService.deleteUserRole(userId, roleId);
295            }
296    
297            @Override
298            public void deleteUserRoles(long userId,
299                    java.util.List<com.liferay.portal.model.Role> Roles) {
300                    _roleLocalService.deleteUserRoles(userId, Roles);
301            }
302    
303            @Override
304            public void deleteUserRoles(long userId, long[] roleIds) {
305                    _roleLocalService.deleteUserRoles(userId, roleIds);
306            }
307    
308            @Override
309            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
310                    return _roleLocalService.dynamicQuery();
311            }
312    
313            /**
314            * Performs a dynamic query on the database and returns the matching rows.
315            *
316            * @param dynamicQuery the dynamic query
317            * @return the matching rows
318            */
319            @Override
320            public <T> java.util.List<T> dynamicQuery(
321                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
322                    return _roleLocalService.dynamicQuery(dynamicQuery);
323            }
324    
325            /**
326            * Performs a dynamic query on the database and returns a range of the matching rows.
327            *
328            * <p>
329            * 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.portal.model.impl.RoleModelImpl}. 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.
330            * </p>
331            *
332            * @param dynamicQuery the dynamic query
333            * @param start the lower bound of the range of model instances
334            * @param end the upper bound of the range of model instances (not inclusive)
335            * @return the range of matching rows
336            */
337            @Override
338            public <T> java.util.List<T> dynamicQuery(
339                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
340                    int end) {
341                    return _roleLocalService.dynamicQuery(dynamicQuery, start, end);
342            }
343    
344            /**
345            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
346            *
347            * <p>
348            * 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.portal.model.impl.RoleModelImpl}. 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.
349            * </p>
350            *
351            * @param dynamicQuery the dynamic query
352            * @param start the lower bound of the range of model instances
353            * @param end the upper bound of the range of model instances (not inclusive)
354            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
355            * @return the ordered range of matching rows
356            */
357            @Override
358            public <T> java.util.List<T> dynamicQuery(
359                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
360                    int end,
361                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
362                    return _roleLocalService.dynamicQuery(dynamicQuery, start, end,
363                            orderByComparator);
364            }
365    
366            /**
367            * Returns the number of rows matching the dynamic query.
368            *
369            * @param dynamicQuery the dynamic query
370            * @return the number of rows matching the dynamic query
371            */
372            @Override
373            public long dynamicQueryCount(
374                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
375                    return _roleLocalService.dynamicQueryCount(dynamicQuery);
376            }
377    
378            /**
379            * Returns the number of rows matching the dynamic query.
380            *
381            * @param dynamicQuery the dynamic query
382            * @param projection the projection to apply to the query
383            * @return the number of rows matching the dynamic query
384            */
385            @Override
386            public long dynamicQueryCount(
387                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
388                    com.liferay.portal.kernel.dao.orm.Projection projection) {
389                    return _roleLocalService.dynamicQueryCount(dynamicQuery, projection);
390            }
391    
392            /**
393            * Returns the role with the name in the company.
394            *
395            * <p>
396            * The method searches the system roles map first for default roles. If a
397            * role with the name is not found, then the method will query the database.
398            * </p>
399            *
400            * @param companyId the primary key of the company
401            * @param name the role's name
402            * @return Returns the role with the name or <code>null</code> if a role
403            with the name could not be found in the company
404            */
405            @Override
406            public com.liferay.portal.model.Role fetchRole(long companyId,
407                    java.lang.String name) {
408                    return _roleLocalService.fetchRole(companyId, name);
409            }
410    
411            @Override
412            public com.liferay.portal.model.Role fetchRole(long roleId) {
413                    return _roleLocalService.fetchRole(roleId);
414            }
415    
416            /**
417            * Returns the role with the matching UUID and company.
418            *
419            * @param uuid the role's UUID
420            * @param companyId the primary key of the company
421            * @return the matching role, or <code>null</code> if a matching role could not be found
422            */
423            @Override
424            public com.liferay.portal.model.Role fetchRoleByUuidAndCompanyId(
425                    java.lang.String uuid, long companyId) {
426                    return _roleLocalService.fetchRoleByUuidAndCompanyId(uuid, companyId);
427            }
428    
429            @Override
430            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
431                    return _roleLocalService.getActionableDynamicQuery();
432            }
433    
434            /**
435            * Returns the default role for the group with the primary key.
436            *
437            * <p>
438            * If the group is a site, then the default role is {@link
439            * RoleConstants#SITE_MEMBER}. If the group is an organization, then the
440            * default role is {@link RoleConstants#ORGANIZATION_USER}. If the group is
441            * a user or user group, then the default role is {@link
442            * RoleConstants#POWER_USER}. For all other group types, the default role is
443            * {@link RoleConstants#USER}.
444            * </p>
445            *
446            * @param groupId the primary key of the group
447            * @return the default role for the group with the primary key
448            */
449            @Override
450            public com.liferay.portal.model.Role getDefaultGroupRole(long groupId)
451                    throws com.liferay.portal.kernel.exception.PortalException {
452                    return _roleLocalService.getDefaultGroupRole(groupId);
453            }
454    
455            @Override
456            public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
457                    com.liferay.portlet.exportimport.lar.PortletDataContext portletDataContext) {
458                    return _roleLocalService.getExportActionableDynamicQuery(portletDataContext);
459            }
460    
461            /**
462            * Returns the groupIds of the groups associated with the role.
463            *
464            * @param roleId the roleId of the role
465            * @return long[] the groupIds of groups associated with the role
466            */
467            @Override
468            public long[] getGroupPrimaryKeys(long roleId) {
469                    return _roleLocalService.getGroupPrimaryKeys(roleId);
470            }
471    
472            @Override
473            public java.util.List<com.liferay.portal.model.Role> getGroupRelatedRoles(
474                    long groupId)
475                    throws com.liferay.portal.kernel.exception.PortalException {
476                    return _roleLocalService.getGroupRelatedRoles(groupId);
477            }
478    
479            @Override
480            public java.util.List<com.liferay.portal.model.Role> getGroupRoles(
481                    long groupId) {
482                    return _roleLocalService.getGroupRoles(groupId);
483            }
484    
485            @Override
486            public java.util.List<com.liferay.portal.model.Role> getGroupRoles(
487                    long groupId, int start, int end) {
488                    return _roleLocalService.getGroupRoles(groupId, start, end);
489            }
490    
491            @Override
492            public java.util.List<com.liferay.portal.model.Role> getGroupRoles(
493                    long groupId, int start, int end,
494                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator) {
495                    return _roleLocalService.getGroupRoles(groupId, start, end,
496                            orderByComparator);
497            }
498    
499            @Override
500            public int getGroupRolesCount(long groupId) {
501                    return _roleLocalService.getGroupRolesCount(groupId);
502            }
503    
504            /**
505            * Returns the OSGi service identifier.
506            *
507            * @return the OSGi service identifier
508            */
509            @Override
510            public java.lang.String getOSGiServiceIdentifier() {
511                    return _roleLocalService.getOSGiServiceIdentifier();
512            }
513    
514            @Override
515            public com.liferay.portal.model.PersistedModel getPersistedModel(
516                    java.io.Serializable primaryKeyObj)
517                    throws com.liferay.portal.kernel.exception.PortalException {
518                    return _roleLocalService.getPersistedModel(primaryKeyObj);
519            }
520    
521            @Override
522            public java.util.List<com.liferay.portal.model.Role> getResourceBlockRoles(
523                    long resourceBlockId, java.lang.String className,
524                    java.lang.String actionId) {
525                    return _roleLocalService.getResourceBlockRoles(resourceBlockId,
526                            className, actionId);
527            }
528    
529            /**
530            * Returns a map of role names to associated action IDs for the named
531            * resource in the company within the permission scope.
532            *
533            * @param companyId the primary key of the company
534            * @param name the resource name
535            * @param scope the permission scope
536            * @param primKey the primary key of the resource's class
537            * @return the role names and action IDs
538            * @see com.liferay.portal.service.persistence.RoleFinder#findByC_N_S_P(
539            long, String, int, String)
540            */
541            @Override
542            public java.util.Map<java.lang.String, java.util.List<java.lang.String>> getResourceRoles(
543                    long companyId, java.lang.String name, int scope,
544                    java.lang.String primKey) {
545                    return _roleLocalService.getResourceRoles(companyId, name, scope,
546                            primKey);
547            }
548    
549            /**
550            * Returns all the roles associated with the action ID in the company within
551            * the permission scope.
552            *
553            * @param companyId the primary key of the company
554            * @param name the resource name
555            * @param scope the permission scope
556            * @param primKey the primary key of the resource's class
557            * @param actionId the name of the resource action
558            * @return the roles
559            * @see com.liferay.portal.service.persistence.RoleFinder#findByC_N_S_P_A(
560            long, String, int, String, String)
561            */
562            @Override
563            public java.util.List<com.liferay.portal.model.Role> getResourceRoles(
564                    long companyId, java.lang.String name, int scope,
565                    java.lang.String primKey, java.lang.String actionId) {
566                    return _roleLocalService.getResourceRoles(companyId, name, scope,
567                            primKey, actionId);
568            }
569    
570            /**
571            * Returns the role with the name in the company.
572            *
573            * <p>
574            * The method searches the system roles map first for default roles. If a
575            * role with the name is not found, then the method will query the database.
576            * </p>
577            *
578            * @param companyId the primary key of the company
579            * @param name the role's name
580            * @return the role with the name
581            */
582            @Override
583            public com.liferay.portal.model.Role getRole(long companyId,
584                    java.lang.String name)
585                    throws com.liferay.portal.kernel.exception.PortalException {
586                    return _roleLocalService.getRole(companyId, name);
587            }
588    
589            /**
590            * Returns the role with the primary key.
591            *
592            * @param roleId the primary key of the role
593            * @return the role
594            * @throws PortalException if a role with the primary key could not be found
595            */
596            @Override
597            public com.liferay.portal.model.Role getRole(long roleId)
598                    throws com.liferay.portal.kernel.exception.PortalException {
599                    return _roleLocalService.getRole(roleId);
600            }
601    
602            /**
603            * Returns the role with the matching UUID and company.
604            *
605            * @param uuid the role's UUID
606            * @param companyId the primary key of the company
607            * @return the matching role
608            * @throws PortalException if a matching role could not be found
609            */
610            @Override
611            public com.liferay.portal.model.Role getRoleByUuidAndCompanyId(
612                    java.lang.String uuid, long companyId)
613                    throws com.liferay.portal.kernel.exception.PortalException {
614                    return _roleLocalService.getRoleByUuidAndCompanyId(uuid, companyId);
615            }
616    
617            /**
618            * Returns all the roles in the company.
619            *
620            * @param companyId the primary key of the company
621            * @return the roles in the company
622            */
623            @Override
624            public java.util.List<com.liferay.portal.model.Role> getRoles(
625                    long companyId) {
626                    return _roleLocalService.getRoles(companyId);
627            }
628    
629            /**
630            * Returns all the roles with the types.
631            *
632            * @param companyId the primary key of the company
633            * @param types the role types (optionally <code>null</code>)
634            * @return the roles with the types
635            */
636            @Override
637            public java.util.List<com.liferay.portal.model.Role> getRoles(
638                    long companyId, int[] types) {
639                    return _roleLocalService.getRoles(companyId, types);
640            }
641    
642            /**
643            * Returns all the roles with the primary keys.
644            *
645            * @param roleIds the primary keys of the roles
646            * @return the roles with the primary keys
647            */
648            @Override
649            public java.util.List<com.liferay.portal.model.Role> getRoles(
650                    long[] roleIds)
651                    throws com.liferay.portal.kernel.exception.PortalException {
652                    return _roleLocalService.getRoles(roleIds);
653            }
654    
655            /**
656            * Returns a range of all the roles.
657            *
658            * <p>
659            * 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.portal.model.impl.RoleModelImpl}. 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.
660            * </p>
661            *
662            * @param start the lower bound of the range of roles
663            * @param end the upper bound of the range of roles (not inclusive)
664            * @return the range of roles
665            */
666            @Override
667            public java.util.List<com.liferay.portal.model.Role> getRoles(int start,
668                    int end) {
669                    return _roleLocalService.getRoles(start, end);
670            }
671    
672            /**
673            * Returns all the roles of the type and subtype.
674            *
675            * @param type the role's type (optionally <code>0</code>)
676            * @param subtype the role's subtype (optionally <code>null</code>)
677            * @return the roles of the type and subtype
678            */
679            @Override
680            public java.util.List<com.liferay.portal.model.Role> getRoles(int type,
681                    java.lang.String subtype) {
682                    return _roleLocalService.getRoles(type, subtype);
683            }
684    
685            /**
686            * Returns the number of roles.
687            *
688            * @return the number of roles
689            */
690            @Override
691            public int getRolesCount() {
692                    return _roleLocalService.getRolesCount();
693            }
694    
695            /**
696            * Returns all the roles of the subtype.
697            *
698            * @param subtype the role's subtype (optionally <code>null</code>)
699            * @return the roles of the subtype
700            */
701            @Override
702            public java.util.List<com.liferay.portal.model.Role> getSubtypeRoles(
703                    java.lang.String subtype) {
704                    return _roleLocalService.getSubtypeRoles(subtype);
705            }
706    
707            /**
708            * Returns the number of roles of the subtype.
709            *
710            * @param subtype the role's subtype (optionally <code>null</code>)
711            * @return the number of roles of the subtype
712            */
713            @Override
714            public int getSubtypeRolesCount(java.lang.String subtype) {
715                    return _roleLocalService.getSubtypeRolesCount(subtype);
716            }
717    
718            /**
719            * Returns the team role in the company.
720            *
721            * @param companyId the primary key of the company
722            * @param teamId the primary key of the team
723            * @return the team role in the company
724            */
725            @Override
726            public com.liferay.portal.model.Role getTeamRole(long companyId, long teamId)
727                    throws com.liferay.portal.kernel.exception.PortalException {
728                    return _roleLocalService.getTeamRole(companyId, teamId);
729            }
730    
731            /**
732            * Returns the team role map for the group.
733            *
734            * @param groupId the primary key of the group
735            * @return the team role map for the group
736            */
737            @Override
738            public java.util.Map<com.liferay.portal.model.Team, com.liferay.portal.model.Role> getTeamRoleMap(
739                    long groupId)
740                    throws com.liferay.portal.kernel.exception.PortalException {
741                    return _roleLocalService.getTeamRoleMap(groupId);
742            }
743    
744            /**
745            * Returns the team roles in the group.
746            *
747            * @param groupId the primary key of the group
748            * @return the team roles in the group
749            */
750            @Override
751            public java.util.List<com.liferay.portal.model.Role> getTeamRoles(
752                    long groupId)
753                    throws com.liferay.portal.kernel.exception.PortalException {
754                    return _roleLocalService.getTeamRoles(groupId);
755            }
756    
757            /**
758            * Returns the team roles in the group, excluding the specified role IDs.
759            *
760            * @param groupId the primary key of the group
761            * @param excludedRoleIds the primary keys of the roles to exclude
762            (optionally <code>null</code>)
763            * @return the team roles in the group, excluding the specified role IDs
764            */
765            @Override
766            public java.util.List<com.liferay.portal.model.Role> getTeamRoles(
767                    long groupId, long[] excludedRoleIds)
768                    throws com.liferay.portal.kernel.exception.PortalException {
769                    return _roleLocalService.getTeamRoles(groupId, excludedRoleIds);
770            }
771    
772            /**
773            * Returns all the roles of the type.
774            *
775            * @param type the role's type (optionally <code>0</code>)
776            * @return the range of the roles of the type
777            */
778            @Override
779            public java.util.List<com.liferay.portal.model.Role> getTypeRoles(int type) {
780                    return _roleLocalService.getTypeRoles(type);
781            }
782    
783            /**
784            * Returns a range of all the roles of the type.
785            *
786            * @param type the role's type (optionally <code>0</code>)
787            * @param start the lower bound of the range of roles to return
788            * @param end the upper bound of the range of roles to return (not
789            inclusive)
790            * @return the range of the roles of the type
791            */
792            @Override
793            public java.util.List<com.liferay.portal.model.Role> getTypeRoles(
794                    int type, int start, int end) {
795                    return _roleLocalService.getTypeRoles(type, start, end);
796            }
797    
798            /**
799            * Returns the number of roles of the type.
800            *
801            * @param type the role's type (optionally <code>0</code>)
802            * @return the number of roles of the type
803            */
804            @Override
805            public int getTypeRolesCount(int type) {
806                    return _roleLocalService.getTypeRolesCount(type);
807            }
808    
809            /**
810            * Returns all the user's roles within the user group.
811            *
812            * @param userId the primary key of the user
813            * @param groupId the primary key of the group
814            * @return the user's roles within the user group
815            * @see com.liferay.portal.service.persistence.RoleFinder#findByUserGroupGroupRole(
816            long, long)
817            */
818            @Override
819            public java.util.List<com.liferay.portal.model.Role> getUserGroupGroupRoles(
820                    long userId, long groupId) {
821                    return _roleLocalService.getUserGroupGroupRoles(userId, groupId);
822            }
823    
824            @Override
825            public java.util.List<com.liferay.portal.model.Role> getUserGroupGroupRoles(
826                    long userId, long groupId, int start, int end) {
827                    return _roleLocalService.getUserGroupGroupRoles(userId, groupId, start,
828                            end);
829            }
830    
831            @Override
832            public int getUserGroupGroupRolesCount(long userId, long groupId) {
833                    return _roleLocalService.getUserGroupGroupRolesCount(userId, groupId);
834            }
835    
836            /**
837            * Returns all the user's roles within the user group.
838            *
839            * @param userId the primary key of the user
840            * @param groupId the primary key of the group
841            * @return the user's roles within the user group
842            * @see com.liferay.portal.service.persistence.RoleFinder#findByUserGroupRole(
843            long, long)
844            */
845            @Override
846            public java.util.List<com.liferay.portal.model.Role> getUserGroupRoles(
847                    long userId, long groupId) {
848                    return _roleLocalService.getUserGroupRoles(userId, groupId);
849            }
850    
851            /**
852            * Returns the userIds of the users associated with the role.
853            *
854            * @param roleId the roleId of the role
855            * @return long[] the userIds of users associated with the role
856            */
857            @Override
858            public long[] getUserPrimaryKeys(long roleId) {
859                    return _roleLocalService.getUserPrimaryKeys(roleId);
860            }
861    
862            /**
863            * Returns all the user's roles within the group.
864            *
865            * @param userId the primary key of the user
866            * @param groupId the primary key of the group
867            * @return the user's roles within the group
868            * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long,
869            long)
870            */
871            @Override
872            public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles(
873                    long userId, long groupId) {
874                    return _roleLocalService.getUserRelatedRoles(userId, groupId);
875            }
876    
877            /**
878            * Returns the union of all the user's roles within the groups.
879            *
880            * @param userId the primary key of the user
881            * @param groupIds the primary keys of the groups
882            * @return the union of all the user's roles within the groups
883            * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long,
884            long[])
885            */
886            @Override
887            public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles(
888                    long userId, long[] groupIds) {
889                    return _roleLocalService.getUserRelatedRoles(userId, groupIds);
890            }
891    
892            /**
893            * Returns the union of all the user's roles within the groups.
894            *
895            * @param userId the primary key of the user
896            * @param groups the groups (optionally <code>null</code>)
897            * @return the union of all the user's roles within the groups
898            * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long,
899            List)
900            */
901            @Override
902            public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles(
903                    long userId, java.util.List<com.liferay.portal.model.Group> groups) {
904                    return _roleLocalService.getUserRelatedRoles(userId, groups);
905            }
906    
907            @Override
908            public java.util.List<com.liferay.portal.model.Role> getUserRoles(
909                    long userId) {
910                    return _roleLocalService.getUserRoles(userId);
911            }
912    
913            @Override
914            public java.util.List<com.liferay.portal.model.Role> getUserRoles(
915                    long userId, int start, int end) {
916                    return _roleLocalService.getUserRoles(userId, start, end);
917            }
918    
919            @Override
920            public java.util.List<com.liferay.portal.model.Role> getUserRoles(
921                    long userId, int start, int end,
922                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator) {
923                    return _roleLocalService.getUserRoles(userId, start, end,
924                            orderByComparator);
925            }
926    
927            @Override
928            public int getUserRolesCount(long userId) {
929                    return _roleLocalService.getUserRolesCount(userId);
930            }
931    
932            @Override
933            public boolean hasGroupRole(long groupId, long roleId) {
934                    return _roleLocalService.hasGroupRole(groupId, roleId);
935            }
936    
937            @Override
938            public boolean hasGroupRoles(long groupId) {
939                    return _roleLocalService.hasGroupRoles(groupId);
940            }
941    
942            /**
943            * Returns <code>true</code> if the user is associated with the named
944            * regular role.
945            *
946            * @param userId the primary key of the user
947            * @param companyId the primary key of the company
948            * @param name the name of the role
949            * @param inherited whether to include the user's inherited roles in the
950            search
951            * @return <code>true</code> if the user is associated with the regular
952            role; <code>false</code> otherwise
953            */
954            @Override
955            public boolean hasUserRole(long userId, long companyId,
956                    java.lang.String name, boolean inherited)
957                    throws com.liferay.portal.kernel.exception.PortalException {
958                    return _roleLocalService.hasUserRole(userId, companyId, name, inherited);
959            }
960    
961            @Override
962            public boolean hasUserRole(long userId, long roleId) {
963                    return _roleLocalService.hasUserRole(userId, roleId);
964            }
965    
966            @Override
967            public boolean hasUserRoles(long userId) {
968                    return _roleLocalService.hasUserRoles(userId);
969            }
970    
971            /**
972            * Returns <code>true</code> if the user has any one of the named regular
973            * roles.
974            *
975            * @param userId the primary key of the user
976            * @param companyId the primary key of the company
977            * @param names the names of the roles
978            * @param inherited whether to include the user's inherited roles in the
979            search
980            * @return <code>true</code> if the user has any one of the regular roles;
981            <code>false</code> otherwise
982            */
983            @Override
984            public boolean hasUserRoles(long userId, long companyId,
985                    java.lang.String[] names, boolean inherited)
986                    throws com.liferay.portal.kernel.exception.PortalException {
987                    return _roleLocalService.hasUserRoles(userId, companyId, names,
988                            inherited);
989            }
990    
991            /**
992            * Returns a role with the name in the company.
993            *
994            * @param companyId the primary key of the company
995            * @param name the role's name (optionally <code>null</code>)
996            * @return the role with the name, or <code>null</code> if a role with the
997            name could not be found in the company
998            */
999            @Override
1000            public com.liferay.portal.model.Role loadFetchRole(long companyId,
1001                    java.lang.String name) {
1002                    return _roleLocalService.loadFetchRole(companyId, name);
1003            }
1004    
1005            /**
1006            * Returns a role with the name in the company.
1007            *
1008            * @param companyId the primary key of the company
1009            * @param name the role's name
1010            * @return the role with the name in the company
1011            */
1012            @Override
1013            public com.liferay.portal.model.Role loadGetRole(long companyId,
1014                    java.lang.String name)
1015                    throws com.liferay.portal.kernel.exception.PortalException {
1016                    return _roleLocalService.loadGetRole(companyId, name);
1017            }
1018    
1019            /**
1020            * Returns an ordered range of all the roles that match the keywords, types,
1021            * and params.
1022            *
1023            * <p>
1024            * Useful when paginating results. Returns a maximum of <code>end -
1025            * start</code> instances. <code>start</code> and <code>end</code> are not
1026            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1027            * refers to the first result in the set. Setting both <code>start</code>
1028            * and <code>end</code> to {@link
1029            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1030            * result set.
1031            * </p>
1032            *
1033            * @param companyId the primary key of the company
1034            * @param keywords the keywords (space separated), which may occur in the
1035            role's name or description (optionally <code>null</code>)
1036            * @param types the role types (optionally <code>null</code>)
1037            * @param params the finder parameters. Can specify values for the
1038            "usersRoles" key. For more information, see {@link
1039            com.liferay.portal.service.persistence.RoleFinder}
1040            * @param start the lower bound of the range of roles to return
1041            * @param end the upper bound of the range of roles to return (not
1042            inclusive)
1043            * @param obc the comparator to order the roles (optionally
1044            <code>null</code>)
1045            * @return the ordered range of the matching roles, ordered by
1046            <code>obc</code>
1047            * @see com.liferay.portal.service.persistence.RoleFinder
1048            */
1049            @Override
1050            public java.util.List<com.liferay.portal.model.Role> search(
1051                    long companyId, java.lang.String keywords, java.lang.Integer[] types,
1052                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1053                    int start, int end,
1054                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) {
1055                    return _roleLocalService.search(companyId, keywords, types, params,
1056                            start, end, obc);
1057            }
1058    
1059            /**
1060            * Returns an ordered range of all the roles that match the keywords and
1061            * types.
1062            *
1063            * <p>
1064            * Useful when paginating results. Returns a maximum of <code>end -
1065            * start</code> instances. <code>start</code> and <code>end</code> are not
1066            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1067            * refers to the first result in the set. Setting both <code>start</code>
1068            * and <code>end</code> to {@link
1069            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1070            * result set.
1071            * </p>
1072            *
1073            * @param companyId the primary key of the company
1074            * @param keywords the keywords (space separated), which may occur in the
1075            role's name or description (optionally <code>null</code>)
1076            * @param types the role types (optionally <code>null</code>)
1077            * @param start the lower bound of the range of roles to return
1078            * @param end the upper bound of the range of roles to return (not
1079            inclusive)
1080            * @param obc the comparator to order the roles (optionally
1081            <code>null</code>)
1082            * @return the ordered range of the matching roles, ordered by
1083            <code>obc</code>
1084            * @see com.liferay.portal.service.persistence.RoleFinder
1085            */
1086            @Override
1087            public java.util.List<com.liferay.portal.model.Role> search(
1088                    long companyId, java.lang.String keywords, java.lang.Integer[] types,
1089                    int start, int end,
1090                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) {
1091                    return _roleLocalService.search(companyId, keywords, types, start, end,
1092                            obc);
1093            }
1094    
1095            /**
1096            * Returns an ordered range of all the roles that match the name,
1097            * description, types, and params.
1098            *
1099            * <p>
1100            * Useful when paginating results. Returns a maximum of <code>end -
1101            * start</code> instances. <code>start</code> and <code>end</code> are not
1102            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1103            * refers to the first result in the set. Setting both <code>start</code>
1104            * and <code>end</code> to {@link
1105            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1106            * result set.
1107            * </p>
1108            *
1109            * @param companyId the primary key of the company
1110            * @param name the role's name (optionally <code>null</code>)
1111            * @param description the role's description (optionally <code>null</code>)
1112            * @param types the role types (optionally <code>null</code>)
1113            * @param params the finder's parameters. Can specify values for the
1114            "usersRoles" key. For more information, see {@link
1115            com.liferay.portal.service.persistence.RoleFinder}
1116            * @param start the lower bound of the range of the roles to return
1117            * @param end the upper bound of the range of the roles to return (not
1118            inclusive)
1119            * @param obc the comparator to order the roles (optionally
1120            <code>null</code>)
1121            * @return the ordered range of the matching roles, ordered by
1122            <code>obc</code>
1123            * @see com.liferay.portal.service.persistence.RoleFinder
1124            */
1125            @Override
1126            public java.util.List<com.liferay.portal.model.Role> search(
1127                    long companyId, java.lang.String name, java.lang.String description,
1128                    java.lang.Integer[] types,
1129                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1130                    int start, int end,
1131                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) {
1132                    return _roleLocalService.search(companyId, name, description, types,
1133                            params, start, end, obc);
1134            }
1135    
1136            /**
1137            * Returns an ordered range of all the roles that match the name,
1138            * description, and types.
1139            *
1140            * <p>
1141            * Useful when paginating results. Returns a maximum of <code>end -
1142            * start</code> instances. <code>start</code> and <code>end</code> are not
1143            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1144            * refers to the first result in the set. Setting both <code>start</code>
1145            * and <code>end</code> to {@link
1146            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1147            * result set.
1148            * </p>
1149            *
1150            * @param companyId the primary key of the company
1151            * @param name the role's name (optionally <code>null</code>)
1152            * @param description the role's description (optionally <code>null</code>)
1153            * @param types the role types (optionally <code>null</code>)
1154            * @param start the lower bound of the range of the roles to return
1155            * @param end the upper bound of the range of the roles to return (not
1156            inclusive)
1157            * @param obc the comparator to order the roles (optionally
1158            <code>null</code>)
1159            * @return the ordered range of the matching roles, ordered by
1160            <code>obc</code>
1161            * @see com.liferay.portal.service.persistence.RoleFinder
1162            */
1163            @Override
1164            public java.util.List<com.liferay.portal.model.Role> search(
1165                    long companyId, java.lang.String name, java.lang.String description,
1166                    java.lang.Integer[] types, int start, int end,
1167                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) {
1168                    return _roleLocalService.search(companyId, name, description, types,
1169                            start, end, obc);
1170            }
1171    
1172            /**
1173            * Returns the number of roles that match the keywords and types.
1174            *
1175            * @param companyId the primary key of the company
1176            * @param keywords the keywords (space separated), which may occur in the
1177            role's name or description (optionally <code>null</code>)
1178            * @param types the role types (optionally <code>null</code>)
1179            * @return the number of matching roles
1180            */
1181            @Override
1182            public int searchCount(long companyId, java.lang.String keywords,
1183                    java.lang.Integer[] types) {
1184                    return _roleLocalService.searchCount(companyId, keywords, types);
1185            }
1186    
1187            /**
1188            * Returns the number of roles that match the keywords, types and params.
1189            *
1190            * @param companyId the primary key of the company
1191            * @param keywords the keywords (space separated), which may occur in the
1192            role's name or description (optionally <code>null</code>)
1193            * @param types the role types (optionally <code>null</code>)
1194            * @param params the finder parameters. For more information, see {@link
1195            com.liferay.portal.service.persistence.RoleFinder}
1196            * @return the number of matching roles
1197            */
1198            @Override
1199            public int searchCount(long companyId, java.lang.String keywords,
1200                    java.lang.Integer[] types,
1201                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
1202                    return _roleLocalService.searchCount(companyId, keywords, types, params);
1203            }
1204    
1205            /**
1206            * Returns the number of roles that match the name, description, and types.
1207            *
1208            * @param companyId the primary key of the company
1209            * @param name the role's name (optionally <code>null</code>)
1210            * @param description the role's description (optionally <code>null</code>)
1211            * @param types the role types (optionally <code>null</code>)
1212            * @return the number of matching roles
1213            */
1214            @Override
1215            public int searchCount(long companyId, java.lang.String name,
1216                    java.lang.String description, java.lang.Integer[] types) {
1217                    return _roleLocalService.searchCount(companyId, name, description, types);
1218            }
1219    
1220            /**
1221            * Returns the number of roles that match the name, description, types, and
1222            * params.
1223            *
1224            * @param companyId the primary key of the company
1225            * @param name the role's name (optionally <code>null</code>)
1226            * @param description the role's description (optionally <code>null</code>)
1227            * @param types the role types (optionally <code>null</code>)
1228            * @param params the finder parameters. Can specify values for the
1229            "usersRoles" key. For more information, see {@link
1230            com.liferay.portal.service.persistence.RoleFinder}
1231            * @return the number of matching roles
1232            */
1233            @Override
1234            public int searchCount(long companyId, java.lang.String name,
1235                    java.lang.String description, java.lang.Integer[] types,
1236                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
1237                    return _roleLocalService.searchCount(companyId, name, description,
1238                            types, params);
1239            }
1240    
1241            @Override
1242            public void setGroupRoles(long groupId, long[] roleIds) {
1243                    _roleLocalService.setGroupRoles(groupId, roleIds);
1244            }
1245    
1246            /**
1247            * @throws PortalException
1248            */
1249            @Override
1250            public void setUserRoles(long userId, long[] roleIds)
1251                    throws com.liferay.portal.kernel.exception.PortalException {
1252                    _roleLocalService.setUserRoles(userId, roleIds);
1253            }
1254    
1255            /**
1256            * Removes the matching roles associated with the user. The user is
1257            * reindexed after the roles are removed.
1258            *
1259            * @param userId the primary key of the user
1260            * @param roleIds the primary keys of the roles
1261            */
1262            @Override
1263            public void unsetUserRoles(long userId, long[] roleIds)
1264                    throws com.liferay.portal.kernel.exception.PortalException {
1265                    _roleLocalService.unsetUserRoles(userId, roleIds);
1266            }
1267    
1268            /**
1269            * Updates the role in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1270            *
1271            * @param role the role
1272            * @return the role that was updated
1273            */
1274            @Override
1275            public com.liferay.portal.model.Role updateRole(
1276                    com.liferay.portal.model.Role role) {
1277                    return _roleLocalService.updateRole(role);
1278            }
1279    
1280            /**
1281            * Updates the role with the primary key.
1282            *
1283            * @param roleId the primary key of the role
1284            * @param name the role's new name
1285            * @param titleMap the new localized titles (optionally <code>null</code>)
1286            to replace those existing for the role
1287            * @param descriptionMap the new localized descriptions (optionally
1288            <code>null</code>) to replace those existing for the role
1289            * @param subtype the role's new subtype (optionally <code>null</code>)
1290            * @param serviceContext the service context to be applied (optionally
1291            <code>null</code>). Can set expando bridge attributes for the
1292            role.
1293            * @return the role with the primary key
1294            */
1295            @Override
1296            public com.liferay.portal.model.Role updateRole(long roleId,
1297                    java.lang.String name,
1298                    java.util.Map<java.util.Locale, java.lang.String> titleMap,
1299                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1300                    java.lang.String subtype,
1301                    com.liferay.portal.service.ServiceContext serviceContext)
1302                    throws com.liferay.portal.kernel.exception.PortalException {
1303                    return _roleLocalService.updateRole(roleId, name, titleMap,
1304                            descriptionMap, subtype, serviceContext);
1305            }
1306    
1307            /**
1308             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
1309             */
1310            @Deprecated
1311            public RoleLocalService getWrappedRoleLocalService() {
1312                    return _roleLocalService;
1313            }
1314    
1315            /**
1316             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
1317             */
1318            @Deprecated
1319            public void setWrappedRoleLocalService(RoleLocalService roleLocalService) {
1320                    _roleLocalService = roleLocalService;
1321            }
1322    
1323            @Override
1324            public RoleLocalService getWrappedService() {
1325                    return _roleLocalService;
1326            }
1327    
1328            @Override
1329            public void setWrappedService(RoleLocalService roleLocalService) {
1330                    _roleLocalService = roleLocalService;
1331            }
1332    
1333            private RoleLocalService _roleLocalService;
1334    }