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.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
021    import com.liferay.portal.kernel.util.OrderByComparator;
022    import com.liferay.portal.kernel.util.ReferenceRegistry;
023    import com.liferay.portal.model.OrgGroupRole;
024    import com.liferay.portal.service.ServiceContext;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the org group role service. This utility wraps {@link com.liferay.portal.service.persistence.impl.OrgGroupRolePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see OrgGroupRolePersistence
037     * @see com.liferay.portal.service.persistence.impl.OrgGroupRolePersistenceImpl
038     * @generated
039     */
040    @ProviderType
041    public class OrgGroupRoleUtil {
042            /*
043             * NOTE FOR DEVELOPERS:
044             *
045             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
046             */
047    
048            /**
049             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
050             */
051            public static void clearCache() {
052                    getPersistence().clearCache();
053            }
054    
055            /**
056             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
057             */
058            public static void clearCache(OrgGroupRole orgGroupRole) {
059                    getPersistence().clearCache(orgGroupRole);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
064             */
065            public static long countWithDynamicQuery(DynamicQuery dynamicQuery) {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<OrgGroupRole> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<OrgGroupRole> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end) {
082                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
083            }
084    
085            /**
086             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
087             */
088            public static List<OrgGroupRole> findWithDynamicQuery(
089                    DynamicQuery dynamicQuery, int start, int end,
090                    OrderByComparator<OrgGroupRole> orderByComparator) {
091                    return getPersistence()
092                                       .findWithDynamicQuery(dynamicQuery, start, end,
093                            orderByComparator);
094            }
095    
096            /**
097             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
098             */
099            public static OrgGroupRole update(OrgGroupRole orgGroupRole) {
100                    return getPersistence().update(orgGroupRole);
101            }
102    
103            /**
104             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
105             */
106            public static OrgGroupRole update(OrgGroupRole orgGroupRole,
107                    ServiceContext serviceContext) {
108                    return getPersistence().update(orgGroupRole, serviceContext);
109            }
110    
111            /**
112            * Returns all the org group roles where groupId = &#63;.
113            *
114            * @param groupId the group ID
115            * @return the matching org group roles
116            */
117            public static List<OrgGroupRole> findByGroupId(long groupId) {
118                    return getPersistence().findByGroupId(groupId);
119            }
120    
121            /**
122            * Returns a range of all the org group roles where groupId = &#63;.
123            *
124            * <p>
125            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrgGroupRoleModelImpl}. 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.
126            * </p>
127            *
128            * @param groupId the group ID
129            * @param start the lower bound of the range of org group roles
130            * @param end the upper bound of the range of org group roles (not inclusive)
131            * @return the range of matching org group roles
132            */
133            public static List<OrgGroupRole> findByGroupId(long groupId, int start,
134                    int end) {
135                    return getPersistence().findByGroupId(groupId, start, end);
136            }
137    
138            /**
139            * Returns an ordered range of all the org group roles where groupId = &#63;.
140            *
141            * <p>
142            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrgGroupRoleModelImpl}. 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.
143            * </p>
144            *
145            * @param groupId the group ID
146            * @param start the lower bound of the range of org group roles
147            * @param end the upper bound of the range of org group roles (not inclusive)
148            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
149            * @return the ordered range of matching org group roles
150            */
151            public static List<OrgGroupRole> findByGroupId(long groupId, int start,
152                    int end, OrderByComparator<OrgGroupRole> orderByComparator) {
153                    return getPersistence()
154                                       .findByGroupId(groupId, start, end, orderByComparator);
155            }
156    
157            /**
158            * Returns the first org group role in the ordered set where groupId = &#63;.
159            *
160            * @param groupId the group ID
161            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
162            * @return the first matching org group role
163            * @throws NoSuchOrgGroupRoleException if a matching org group role could not be found
164            */
165            public static OrgGroupRole findByGroupId_First(long groupId,
166                    OrderByComparator<OrgGroupRole> orderByComparator)
167                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
168                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
169            }
170    
171            /**
172            * Returns the first org group role in the ordered set where groupId = &#63;.
173            *
174            * @param groupId the group ID
175            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
176            * @return the first matching org group role, or <code>null</code> if a matching org group role could not be found
177            */
178            public static OrgGroupRole fetchByGroupId_First(long groupId,
179                    OrderByComparator<OrgGroupRole> orderByComparator) {
180                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
181            }
182    
183            /**
184            * Returns the last org group role in the ordered set where groupId = &#63;.
185            *
186            * @param groupId the group ID
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the last matching org group role
189            * @throws NoSuchOrgGroupRoleException if a matching org group role could not be found
190            */
191            public static OrgGroupRole findByGroupId_Last(long groupId,
192                    OrderByComparator<OrgGroupRole> orderByComparator)
193                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
194                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
195            }
196    
197            /**
198            * Returns the last org group role in the ordered set where groupId = &#63;.
199            *
200            * @param groupId the group ID
201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
202            * @return the last matching org group role, or <code>null</code> if a matching org group role could not be found
203            */
204            public static OrgGroupRole fetchByGroupId_Last(long groupId,
205                    OrderByComparator<OrgGroupRole> orderByComparator) {
206                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
207            }
208    
209            /**
210            * Returns the org group roles before and after the current org group role in the ordered set where groupId = &#63;.
211            *
212            * @param orgGroupRolePK the primary key of the current org group role
213            * @param groupId the group ID
214            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
215            * @return the previous, current, and next org group role
216            * @throws NoSuchOrgGroupRoleException if a org group role with the primary key could not be found
217            */
218            public static OrgGroupRole[] findByGroupId_PrevAndNext(
219                    com.liferay.portal.service.persistence.OrgGroupRolePK orgGroupRolePK,
220                    long groupId, OrderByComparator<OrgGroupRole> orderByComparator)
221                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
222                    return getPersistence()
223                                       .findByGroupId_PrevAndNext(orgGroupRolePK, groupId,
224                            orderByComparator);
225            }
226    
227            /**
228            * Removes all the org group roles where groupId = &#63; from the database.
229            *
230            * @param groupId the group ID
231            */
232            public static void removeByGroupId(long groupId) {
233                    getPersistence().removeByGroupId(groupId);
234            }
235    
236            /**
237            * Returns the number of org group roles where groupId = &#63;.
238            *
239            * @param groupId the group ID
240            * @return the number of matching org group roles
241            */
242            public static int countByGroupId(long groupId) {
243                    return getPersistence().countByGroupId(groupId);
244            }
245    
246            /**
247            * Returns all the org group roles where roleId = &#63;.
248            *
249            * @param roleId the role ID
250            * @return the matching org group roles
251            */
252            public static List<OrgGroupRole> findByRoleId(long roleId) {
253                    return getPersistence().findByRoleId(roleId);
254            }
255    
256            /**
257            * Returns a range of all the org group roles where roleId = &#63;.
258            *
259            * <p>
260            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrgGroupRoleModelImpl}. 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.
261            * </p>
262            *
263            * @param roleId the role ID
264            * @param start the lower bound of the range of org group roles
265            * @param end the upper bound of the range of org group roles (not inclusive)
266            * @return the range of matching org group roles
267            */
268            public static List<OrgGroupRole> findByRoleId(long roleId, int start,
269                    int end) {
270                    return getPersistence().findByRoleId(roleId, start, end);
271            }
272    
273            /**
274            * Returns an ordered range of all the org group roles where roleId = &#63;.
275            *
276            * <p>
277            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrgGroupRoleModelImpl}. 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.
278            * </p>
279            *
280            * @param roleId the role ID
281            * @param start the lower bound of the range of org group roles
282            * @param end the upper bound of the range of org group roles (not inclusive)
283            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
284            * @return the ordered range of matching org group roles
285            */
286            public static List<OrgGroupRole> findByRoleId(long roleId, int start,
287                    int end, OrderByComparator<OrgGroupRole> orderByComparator) {
288                    return getPersistence()
289                                       .findByRoleId(roleId, start, end, orderByComparator);
290            }
291    
292            /**
293            * Returns the first org group role in the ordered set where roleId = &#63;.
294            *
295            * @param roleId the role ID
296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
297            * @return the first matching org group role
298            * @throws NoSuchOrgGroupRoleException if a matching org group role could not be found
299            */
300            public static OrgGroupRole findByRoleId_First(long roleId,
301                    OrderByComparator<OrgGroupRole> orderByComparator)
302                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
303                    return getPersistence().findByRoleId_First(roleId, orderByComparator);
304            }
305    
306            /**
307            * Returns the first org group role in the ordered set where roleId = &#63;.
308            *
309            * @param roleId the role ID
310            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
311            * @return the first matching org group role, or <code>null</code> if a matching org group role could not be found
312            */
313            public static OrgGroupRole fetchByRoleId_First(long roleId,
314                    OrderByComparator<OrgGroupRole> orderByComparator) {
315                    return getPersistence().fetchByRoleId_First(roleId, orderByComparator);
316            }
317    
318            /**
319            * Returns the last org group role in the ordered set where roleId = &#63;.
320            *
321            * @param roleId the role ID
322            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
323            * @return the last matching org group role
324            * @throws NoSuchOrgGroupRoleException if a matching org group role could not be found
325            */
326            public static OrgGroupRole findByRoleId_Last(long roleId,
327                    OrderByComparator<OrgGroupRole> orderByComparator)
328                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
329                    return getPersistence().findByRoleId_Last(roleId, orderByComparator);
330            }
331    
332            /**
333            * Returns the last org group role in the ordered set where roleId = &#63;.
334            *
335            * @param roleId the role ID
336            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
337            * @return the last matching org group role, or <code>null</code> if a matching org group role could not be found
338            */
339            public static OrgGroupRole fetchByRoleId_Last(long roleId,
340                    OrderByComparator<OrgGroupRole> orderByComparator) {
341                    return getPersistence().fetchByRoleId_Last(roleId, orderByComparator);
342            }
343    
344            /**
345            * Returns the org group roles before and after the current org group role in the ordered set where roleId = &#63;.
346            *
347            * @param orgGroupRolePK the primary key of the current org group role
348            * @param roleId the role ID
349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
350            * @return the previous, current, and next org group role
351            * @throws NoSuchOrgGroupRoleException if a org group role with the primary key could not be found
352            */
353            public static OrgGroupRole[] findByRoleId_PrevAndNext(
354                    com.liferay.portal.service.persistence.OrgGroupRolePK orgGroupRolePK,
355                    long roleId, OrderByComparator<OrgGroupRole> orderByComparator)
356                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
357                    return getPersistence()
358                                       .findByRoleId_PrevAndNext(orgGroupRolePK, roleId,
359                            orderByComparator);
360            }
361    
362            /**
363            * Removes all the org group roles where roleId = &#63; from the database.
364            *
365            * @param roleId the role ID
366            */
367            public static void removeByRoleId(long roleId) {
368                    getPersistence().removeByRoleId(roleId);
369            }
370    
371            /**
372            * Returns the number of org group roles where roleId = &#63;.
373            *
374            * @param roleId the role ID
375            * @return the number of matching org group roles
376            */
377            public static int countByRoleId(long roleId) {
378                    return getPersistence().countByRoleId(roleId);
379            }
380    
381            /**
382            * Caches the org group role in the entity cache if it is enabled.
383            *
384            * @param orgGroupRole the org group role
385            */
386            public static void cacheResult(OrgGroupRole orgGroupRole) {
387                    getPersistence().cacheResult(orgGroupRole);
388            }
389    
390            /**
391            * Caches the org group roles in the entity cache if it is enabled.
392            *
393            * @param orgGroupRoles the org group roles
394            */
395            public static void cacheResult(List<OrgGroupRole> orgGroupRoles) {
396                    getPersistence().cacheResult(orgGroupRoles);
397            }
398    
399            /**
400            * Creates a new org group role with the primary key. Does not add the org group role to the database.
401            *
402            * @param orgGroupRolePK the primary key for the new org group role
403            * @return the new org group role
404            */
405            public static OrgGroupRole create(
406                    com.liferay.portal.service.persistence.OrgGroupRolePK orgGroupRolePK) {
407                    return getPersistence().create(orgGroupRolePK);
408            }
409    
410            /**
411            * Removes the org group role with the primary key from the database. Also notifies the appropriate model listeners.
412            *
413            * @param orgGroupRolePK the primary key of the org group role
414            * @return the org group role that was removed
415            * @throws NoSuchOrgGroupRoleException if a org group role with the primary key could not be found
416            */
417            public static OrgGroupRole remove(
418                    com.liferay.portal.service.persistence.OrgGroupRolePK orgGroupRolePK)
419                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
420                    return getPersistence().remove(orgGroupRolePK);
421            }
422    
423            public static OrgGroupRole updateImpl(OrgGroupRole orgGroupRole) {
424                    return getPersistence().updateImpl(orgGroupRole);
425            }
426    
427            /**
428            * Returns the org group role with the primary key or throws a {@link NoSuchOrgGroupRoleException} if it could not be found.
429            *
430            * @param orgGroupRolePK the primary key of the org group role
431            * @return the org group role
432            * @throws NoSuchOrgGroupRoleException if a org group role with the primary key could not be found
433            */
434            public static OrgGroupRole findByPrimaryKey(
435                    com.liferay.portal.service.persistence.OrgGroupRolePK orgGroupRolePK)
436                    throws com.liferay.portal.NoSuchOrgGroupRoleException {
437                    return getPersistence().findByPrimaryKey(orgGroupRolePK);
438            }
439    
440            /**
441            * Returns the org group role with the primary key or returns <code>null</code> if it could not be found.
442            *
443            * @param orgGroupRolePK the primary key of the org group role
444            * @return the org group role, or <code>null</code> if a org group role with the primary key could not be found
445            */
446            public static OrgGroupRole fetchByPrimaryKey(
447                    com.liferay.portal.service.persistence.OrgGroupRolePK orgGroupRolePK) {
448                    return getPersistence().fetchByPrimaryKey(orgGroupRolePK);
449            }
450    
451            public static java.util.Map<java.io.Serializable, OrgGroupRole> fetchByPrimaryKeys(
452                    java.util.Set<java.io.Serializable> primaryKeys) {
453                    return getPersistence().fetchByPrimaryKeys(primaryKeys);
454            }
455    
456            /**
457            * Returns all the org group roles.
458            *
459            * @return the org group roles
460            */
461            public static List<OrgGroupRole> findAll() {
462                    return getPersistence().findAll();
463            }
464    
465            /**
466            * Returns a range of all the org group roles.
467            *
468            * <p>
469            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrgGroupRoleModelImpl}. 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.
470            * </p>
471            *
472            * @param start the lower bound of the range of org group roles
473            * @param end the upper bound of the range of org group roles (not inclusive)
474            * @return the range of org group roles
475            */
476            public static List<OrgGroupRole> findAll(int start, int end) {
477                    return getPersistence().findAll(start, end);
478            }
479    
480            /**
481            * Returns an ordered range of all the org group roles.
482            *
483            * <p>
484            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link OrgGroupRoleModelImpl}. 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.
485            * </p>
486            *
487            * @param start the lower bound of the range of org group roles
488            * @param end the upper bound of the range of org group roles (not inclusive)
489            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
490            * @return the ordered range of org group roles
491            */
492            public static List<OrgGroupRole> findAll(int start, int end,
493                    OrderByComparator<OrgGroupRole> orderByComparator) {
494                    return getPersistence().findAll(start, end, orderByComparator);
495            }
496    
497            /**
498            * Removes all the org group roles from the database.
499            */
500            public static void removeAll() {
501                    getPersistence().removeAll();
502            }
503    
504            /**
505            * Returns the number of org group roles.
506            *
507            * @return the number of org group roles
508            */
509            public static int countAll() {
510                    return getPersistence().countAll();
511            }
512    
513            public static OrgGroupRolePersistence getPersistence() {
514                    if (_persistence == null) {
515                            _persistence = (OrgGroupRolePersistence)PortalBeanLocatorUtil.locate(OrgGroupRolePersistence.class.getName());
516    
517                            ReferenceRegistry.registerReference(OrgGroupRoleUtil.class,
518                                    "_persistence");
519                    }
520    
521                    return _persistence;
522            }
523    
524            /**
525             * @deprecated As of 6.2.0
526             */
527            @Deprecated
528            public void setPersistence(OrgGroupRolePersistence persistence) {
529            }
530    
531            private static OrgGroupRolePersistence _persistence;
532    }