001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatamapping.service;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
020    import com.liferay.portal.kernel.util.ReferenceRegistry;
021    
022    /**
023     * Provides the remote service utility for DDMStructure. This utility wraps
024     * {@link com.liferay.portlet.dynamicdatamapping.service.impl.DDMStructureServiceImpl} and is the
025     * primary access point for service operations in application layer code running
026     * on a remote server. Methods of this service are expected to have security
027     * checks based on the propagated JAAS credentials because this service can be
028     * accessed remotely.
029     *
030     * @author Brian Wing Shun Chan
031     * @see DDMStructureService
032     * @see com.liferay.portlet.dynamicdatamapping.service.base.DDMStructureServiceBaseImpl
033     * @see com.liferay.portlet.dynamicdatamapping.service.impl.DDMStructureServiceImpl
034     * @generated
035     */
036    @ProviderType
037    public class DDMStructureServiceUtil {
038            /*
039             * NOTE FOR DEVELOPERS:
040             *
041             * Never modify this class directly. Add custom service methods to {@link com.liferay.portlet.dynamicdatamapping.service.impl.DDMStructureServiceImpl} and rerun ServiceBuilder to regenerate this class.
042             */
043    
044            /**
045            * Returns the Spring bean ID for this bean.
046            *
047            * @return the Spring bean ID for this bean
048            */
049            public static java.lang.String getBeanIdentifier() {
050                    return getService().getBeanIdentifier();
051            }
052    
053            /**
054            * Sets the Spring bean ID for this bean.
055            *
056            * @param beanIdentifier the Spring bean ID for this bean
057            */
058            public static void setBeanIdentifier(java.lang.String beanIdentifier) {
059                    getService().setBeanIdentifier(beanIdentifier);
060            }
061    
062            /**
063            * Adds a structure referencing a default parent structure, using the portal
064            * property <code>dynamic.data.lists.storage.type</code> storage type and
065            * default structure type.
066            *
067            * @param userId the primary key of the structure's creator/owner
068            * @param groupId the primary key of the group
069            * @param classNameId the primary key of the class name for the structure's
070            related model
071            * @param nameMap the structure's locales and localized names
072            * @param descriptionMap the structure's locales and localized descriptions
073            * @param xsd the structure's XML schema definition
074            * @param serviceContext the service context to be applied. Can set the
075            UUID, creation date, modification date, guest permissions, and
076            group permissions for the structure.
077            * @return the structure
078            * @throws PortalException if a user with the primary key could not be
079            found, if the user did not have permission to add the structure,
080            if the XSD was not well-formed, or if a portal exception occurred
081            * @throws SystemException if a system exception occurred
082            */
083            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
084                    long userId, long groupId, long classNameId,
085                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
086                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
087                    java.lang.String xsd,
088                    com.liferay.portal.service.ServiceContext serviceContext)
089                    throws com.liferay.portal.kernel.exception.PortalException,
090                            com.liferay.portal.kernel.exception.SystemException {
091                    return getService()
092                                       .addStructure(userId, groupId, classNameId, nameMap,
093                            descriptionMap, xsd, serviceContext);
094            }
095    
096            /**
097            * Adds a structure referencing its parent structure.
098            *
099            * @param groupId the primary key of the group
100            * @param parentStructureId the primary key of the parent structure
101            (optionally {@link
102            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants#DEFAULT_PARENT_STRUCTURE_ID})
103            * @param classNameId the primary key of the class name for the structure's
104            related model
105            * @param structureKey the unique string identifying the structure
106            (optionally <code>null</code>)
107            * @param nameMap the structure's locales and localized names
108            * @param descriptionMap the structure's locales and localized descriptions
109            * @param xsd the structure's XML schema definition
110            * @param storageType the structure's storage type. It can be "xml" or
111            "expando". For more information, see {@link
112            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
113            * @param type the structure's type. For more information, see {@link
114            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
115            * @param serviceContext the service context to be applied. Can set the
116            UUID, creation date, modification date, guest permissions, and
117            group permissions for the structure.
118            * @return the structure
119            * @throws PortalException if the user did not have permission to add the
120            structure, if the XSD is not well formed, or if a portal
121            exception occurred
122            * @throws SystemException if a system exception occurred
123            */
124            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
125                    long groupId, long parentStructureId, long classNameId,
126                    java.lang.String structureKey,
127                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
128                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
129                    java.lang.String xsd, java.lang.String storageType, int type,
130                    com.liferay.portal.service.ServiceContext serviceContext)
131                    throws com.liferay.portal.kernel.exception.PortalException,
132                            com.liferay.portal.kernel.exception.SystemException {
133                    return getService()
134                                       .addStructure(groupId, parentStructureId, classNameId,
135                            structureKey, nameMap, descriptionMap, xsd, storageType, type,
136                            serviceContext);
137            }
138    
139            /**
140            * Adds a structure referencing the parent structure by its structure key.
141            * In case the parent structure is not found, it uses the default parent
142            * structure ID.
143            *
144            * @param userId the primary key of the structure's creator/owner
145            * @param groupId the primary key of the group
146            * @param parentStructureKey the unique string identifying the structure
147            * @param classNameId the primary key of the class name for the structure's
148            related model
149            * @param structureKey unique string identifying the structure (optionally
150            <code>null</code>)
151            * @param nameMap the structure's locales and localized names
152            * @param descriptionMap the structure's locales and localized descriptions
153            * @param xsd the XML schema definition of the structure
154            * @param storageType the storage type of the structure. It can be XML or
155            expando. For more information, see {@link
156            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
157            * @param type the structure's type. For more information, see {@link
158            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
159            * @param serviceContext the service context to be applied. Must have the
160            <code>ddmResource</code> attribute to check permissions. Can set
161            the UUID, creation date, modification date, guest permissions,
162            and group permissions for the structure.
163            * @return the structure
164            * @throws PortalException if a user with the primary key could not be
165            found, if the user did not have permission to add the structure,
166            if the XSD was not well-formed, or if a portal exception occurred
167            * @throws SystemException if a system exception occurred
168            */
169            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
170                    long userId, long groupId, java.lang.String parentStructureKey,
171                    long classNameId, java.lang.String structureKey,
172                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
173                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
174                    java.lang.String xsd, java.lang.String storageType, int type,
175                    com.liferay.portal.service.ServiceContext serviceContext)
176                    throws com.liferay.portal.kernel.exception.PortalException,
177                            com.liferay.portal.kernel.exception.SystemException {
178                    return getService()
179                                       .addStructure(userId, groupId, parentStructureKey,
180                            classNameId, structureKey, nameMap, descriptionMap, xsd,
181                            storageType, type, serviceContext);
182            }
183    
184            /**
185            * Copies a structure, creating a new structure with all the values
186            * extracted from the original one. The new structure supports a new name
187            * and description.
188            *
189            * @param structureId the primary key of the structure to be copied
190            * @param nameMap the new structure's locales and localized names
191            * @param descriptionMap the new structure's locales and localized
192            descriptions
193            * @param serviceContext the service context to be applied. Can set the
194            UUID, creation date, modification date, guest permissions, and
195            group permissions for the structure.
196            * @return the new structure
197            * @throws PortalException if the user did not have permission to add the
198            structure or if a portal exception occurred
199            * @throws SystemException if a system exception occurred
200            */
201            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
202                    long structureId,
203                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
204                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
205                    com.liferay.portal.service.ServiceContext serviceContext)
206                    throws com.liferay.portal.kernel.exception.PortalException,
207                            com.liferay.portal.kernel.exception.SystemException {
208                    return getService()
209                                       .copyStructure(structureId, nameMap, descriptionMap,
210                            serviceContext);
211            }
212    
213            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
214                    long structureId,
215                    com.liferay.portal.service.ServiceContext serviceContext)
216                    throws com.liferay.portal.kernel.exception.PortalException,
217                            com.liferay.portal.kernel.exception.SystemException {
218                    return getService().copyStructure(structureId, serviceContext);
219            }
220    
221            /**
222            * Deletes the structure and its resources.
223            *
224            * <p>
225            * Before deleting the structure, the system verifies whether the structure
226            * is required by another entity. If it is needed, an exception is thrown.
227            * </p>
228            *
229            * @param structureId the primary key of the structure to be deleted
230            * @throws PortalException if the user did not have permission to delete the
231            structure or if a portal exception occurred
232            * @throws SystemException if a system exception occurred
233            */
234            public static void deleteStructure(long structureId)
235                    throws com.liferay.portal.kernel.exception.PortalException,
236                            com.liferay.portal.kernel.exception.SystemException {
237                    getService().deleteStructure(structureId);
238            }
239    
240            /**
241            * Returns the structure matching the class name ID, structure key, and
242            * group.
243            *
244            * @param groupId the primary key of the group
245            * @param classNameId the primary key of the class name for the structure's
246            related model
247            * @param structureKey the unique string identifying the structure
248            * @return the matching structure, or <code>null</code> if a matching
249            structure could not be found
250            * @throws PortalException if the user did not have permission to view the
251            structure or if a portal exception occurred
252            * @throws SystemException if a system exception occurred
253            */
254            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
255                    long groupId, long classNameId, java.lang.String structureKey)
256                    throws com.liferay.portal.kernel.exception.PortalException,
257                            com.liferay.portal.kernel.exception.SystemException {
258                    return getService().fetchStructure(groupId, classNameId, structureKey);
259            }
260    
261            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
262                    long groupId, long classNameId, java.lang.String structureKey,
263                    boolean includeAncestorStructures)
264                    throws com.liferay.portal.kernel.exception.PortalException,
265                            com.liferay.portal.kernel.exception.SystemException {
266                    return getService()
267                                       .fetchStructure(groupId, classNameId, structureKey,
268                            includeAncestorStructures);
269            }
270    
271            /**
272            * Returns the structure with the ID.
273            *
274            * @param structureId the primary key of the structure
275            * @return the structure with the ID
276            * @throws PortalException if the user did not have permission to view the
277            structure or if a structure with the ID could not be found
278            * @throws SystemException if a system exception occurred
279            */
280            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
281                    long structureId)
282                    throws com.liferay.portal.kernel.exception.PortalException,
283                            com.liferay.portal.kernel.exception.SystemException {
284                    return getService().getStructure(structureId);
285            }
286    
287            /**
288            * Returns the structure matching the class name ID, structure key, and
289            * group.
290            *
291            * @param groupId the primary key of the structure's group
292            * @param classNameId the primary key of the class name for the structure's
293            related model
294            * @param structureKey the unique string identifying the structure
295            * @return the matching structure
296            * @throws PortalException if the user did not have permission to view the
297            structure or if a matching structure could not be found
298            * @throws SystemException if a system exception occurred
299            */
300            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
301                    long groupId, long classNameId, java.lang.String structureKey)
302                    throws com.liferay.portal.kernel.exception.PortalException,
303                            com.liferay.portal.kernel.exception.SystemException {
304                    return getService().getStructure(groupId, classNameId, structureKey);
305            }
306    
307            /**
308            * Returns the structure matching the class name ID, structure key, and
309            * group, optionally in the global scope.
310            *
311            * <p>
312            * This method first searches in the group. If the structure is still not
313            * found and <code>includeGlobalStructures</code> is set to
314            * <code>true</code>, this method searches the global group.
315            * </p>
316            *
317            * @param groupId the primary key of the structure's group
318            * @param classNameId the primary key of the class name for the structure's
319            related model
320            * @param structureKey the unique string identifying the structure
321            * @param includeGlobalStructures whether to include the global scope in
322            the search
323            * @return the matching structure
324            * @throws PortalException if the user did not have permission to view the
325            structure or if a matching structure could not be found
326            * @throws SystemException if a system exception occurred
327            */
328            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
329                    long groupId, long classNameId, java.lang.String structureKey,
330                    boolean includeGlobalStructures)
331                    throws com.liferay.portal.kernel.exception.PortalException,
332                            com.liferay.portal.kernel.exception.SystemException {
333                    return getService()
334                                       .getStructure(groupId, classNameId, structureKey,
335                            includeGlobalStructures);
336            }
337    
338            /**
339            * Returns all the structures in the group that the user has permission to
340            * view.
341            *
342            * @param groupId the primary key of the group
343            * @return the structures in the group that the user has permission to view
344            * @throws SystemException if a system exception occurred
345            */
346            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
347                    long groupId)
348                    throws com.liferay.portal.kernel.exception.SystemException {
349                    return getService().getStructures(groupId);
350            }
351    
352            /**
353            * Returns all the structures in the groups that the user has permission to
354            * view.
355            *
356            * @param groupIds the primary key of the groups
357            * @return the structures in the groups that the user has permission to view
358            * @throws SystemException if a system exception occurred
359            */
360            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
361                    long[] groupIds)
362                    throws com.liferay.portal.kernel.exception.SystemException {
363                    return getService().getStructures(groupIds);
364            }
365    
366            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
367                    long[] groupIds, long classNameId)
368                    throws com.liferay.portal.kernel.exception.SystemException {
369                    return getService().getStructures(groupIds, classNameId);
370            }
371    
372            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
373                    long[] groupIds, long classNameId, int start, int end)
374                    throws com.liferay.portal.kernel.exception.SystemException {
375                    return getService().getStructures(groupIds, classNameId, start, end);
376            }
377    
378            /**
379            * Returns an ordered range of all the structures matching the groups and
380            * class name IDs, and matching the keywords in the structure names and
381            * descriptions.
382            *
383            * <p>
384            * Useful when paginating results. Returns a maximum of <code>end -
385            * start</code> instances. <code>start</code> and <code>end</code> are not
386            * primary keys, they are indexes in the result set. Thus, <code>0</code>
387            * refers to the first result in the set. Setting both <code>start</code>
388            * and <code>end</code> to {@link
389            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
390            * result set.
391            * </p>
392            *
393            * @param companyId the primary key of the structure's company
394            * @param groupIds the primary keys of the groups
395            * @param classNameIds the primary keys of the class names of the models
396            the structures are related to
397            * @param keywords the keywords (space separated), which may occur in the
398            structure's name or description (optionally <code>null</code>)
399            * @param start the lower bound of the range of structures to return
400            * @param end the upper bound of the range of structures to return (not
401            inclusive)
402            * @param orderByComparator the comparator to order the structures
403            (optionally <code>null</code>)
404            * @return the range of matching structures ordered by the comparator
405            * @throws SystemException if a system exception occurred
406            */
407            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
408                    long companyId, long[] groupIds, long[] classNameIds,
409                    java.lang.String keywords, int start, int end,
410                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
411                    throws com.liferay.portal.kernel.exception.SystemException {
412                    return getService()
413                                       .search(companyId, groupIds, classNameIds, keywords, start,
414                            end, orderByComparator);
415            }
416    
417            /**
418            * Returns an ordered range of all the structures matching the groups, class
419            * name IDs, name keyword, description keyword, storage type, and type.
420            *
421            * <p>
422            * Useful when paginating results. Returns a maximum of <code>end -
423            * start</code> instances. <code>start</code> and <code>end</code> are not
424            * primary keys, they are indexes in the result set. Thus, <code>0</code>
425            * refers to the first result in the set. Setting both <code>start</code>
426            * and <code>end</code> to {@link
427            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
428            * result set.
429            * </p>
430            *
431            * @param companyId the primary key of the structure's company
432            * @param groupIds the primary keys of the groups
433            * @param classNameIds the primary keys of the class names of the models
434            the structures are related to
435            * @param name the name keywords
436            * @param description the description keywords
437            * @param storageType the structure's storage type. It can be "xml" or
438            "expando". For more information, see {@link
439            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
440            * @param type the structure's type. For more information, see {@link
441            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
442            * @param andOperator whether every field must match its keywords, or just
443            one field
444            * @param start the lower bound of the range of structures to return
445            * @param end the upper bound of the range of structures to return (not
446            inclusive)
447            * @param orderByComparator the comparator to order the structures
448            (optionally <code>null</code>)
449            * @return the range of matching structures ordered by the comparator
450            * @throws SystemException if a system exception occurred
451            */
452            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
453                    long companyId, long[] groupIds, long[] classNameIds,
454                    java.lang.String name, java.lang.String description,
455                    java.lang.String storageType, int type, boolean andOperator, int start,
456                    int end,
457                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
458                    throws com.liferay.portal.kernel.exception.SystemException {
459                    return getService()
460                                       .search(companyId, groupIds, classNameIds, name,
461                            description, storageType, type, andOperator, start, end,
462                            orderByComparator);
463            }
464    
465            /**
466            * Returns the number of structures matching the groups and class name IDs,
467            * and matching the keywords in the structure names and descriptions.
468            *
469            * @param companyId the primary key of the structure's company
470            * @param groupIds the primary keys of the groups
471            * @param classNameIds the primary keys of the class names of the models
472            the structures are related to
473            * @param keywords the keywords (space separated), which may occur in the
474            structure's name or description (optionally <code>null</code>)
475            * @return the number of matching structures
476            * @throws SystemException if a system exception occurred
477            */
478            public static int searchCount(long companyId, long[] groupIds,
479                    long[] classNameIds, java.lang.String keywords)
480                    throws com.liferay.portal.kernel.exception.SystemException {
481                    return getService()
482                                       .searchCount(companyId, groupIds, classNameIds, keywords);
483            }
484    
485            /**
486            * Returns the number of structures matching the groups, class name IDs,
487            * name keyword, description keyword, storage type, and type
488            *
489            * @param companyId the primary key of the structure's company
490            * @param groupIds the primary keys of the groups
491            * @param classNameIds the primary keys of the class names of the models
492            the structure's are related to
493            * @param name the name keywords
494            * @param description the description keywords
495            * @param storageType the structure's storage type. It can be "xml" or
496            "expando". For more information, see {@link
497            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
498            * @param type the structure's type. For more information, see {@link
499            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
500            * @param andOperator whether every field must match its keywords, or just
501            one field
502            * @return the number of matching structures
503            * @throws SystemException if a system exception occurred
504            */
505            public static int searchCount(long companyId, long[] groupIds,
506                    long[] classNameIds, java.lang.String name,
507                    java.lang.String description, java.lang.String storageType, int type,
508                    boolean andOperator)
509                    throws com.liferay.portal.kernel.exception.SystemException {
510                    return getService()
511                                       .searchCount(companyId, groupIds, classNameIds, name,
512                            description, storageType, type, andOperator);
513            }
514    
515            /**
516            * Updates the structure matching the class name ID, structure key, and
517            * group, replacing its old parent structure, name map, description map, and
518            * XSD with new ones.
519            *
520            * @param groupId the primary key of the group
521            * @param parentStructureId the primary key of the new parent structure
522            * @param classNameId the primary key of the class name for the structure's
523            related model
524            * @param structureKey the unique string identifying the structure
525            * @param nameMap the structure's new locales and localized names
526            * @param descriptionMap the structure's new locales and localized
527            description
528            * @param xsd the structure's new XML schema definition
529            * @param serviceContext the service context to be applied. Can set the
530            modification date.
531            * @return the updated structure
532            * @throws PortalException if the user did not have permission to update the
533            structure or if a portal exception occurred
534            * @throws SystemException if a system exception occurred
535            */
536            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
537                    long groupId, long parentStructureId, long classNameId,
538                    java.lang.String structureKey,
539                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
540                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
541                    java.lang.String xsd,
542                    com.liferay.portal.service.ServiceContext serviceContext)
543                    throws com.liferay.portal.kernel.exception.PortalException,
544                            com.liferay.portal.kernel.exception.SystemException {
545                    return getService()
546                                       .updateStructure(groupId, parentStructureId, classNameId,
547                            structureKey, nameMap, descriptionMap, xsd, serviceContext);
548            }
549    
550            /**
551            * Updates the structure matching the structure ID, replacing the old parent
552            * structure ID, name map, description map, and XSD with the new values.
553            *
554            * @param structureId the primary key of the structure
555            * @param parentStructureId the new parent structure primary key
556            * @param nameMap the structure's new locales and localized names
557            * @param descriptionMap the structure's new locales and localized
558            description
559            * @param xsd the new XML schema definition of the structure
560            * @param serviceContext the service context to be applied. Can set the
561            modification date.
562            * @return the updated structure
563            * @throws PortalException if the user did not have permission to update the
564            structure or if a portal exception occurred
565            * @throws SystemException if a system exception occurred
566            */
567            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
568                    long structureId, long parentStructureId,
569                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
570                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
571                    java.lang.String xsd,
572                    com.liferay.portal.service.ServiceContext serviceContext)
573                    throws com.liferay.portal.kernel.exception.PortalException,
574                            com.liferay.portal.kernel.exception.SystemException {
575                    return getService()
576                                       .updateStructure(structureId, parentStructureId, nameMap,
577                            descriptionMap, xsd, serviceContext);
578            }
579    
580            public static DDMStructureService getService() {
581                    if (_service == null) {
582                            _service = (DDMStructureService)PortalBeanLocatorUtil.locate(DDMStructureService.class.getName());
583    
584                            ReferenceRegistry.registerReference(DDMStructureServiceUtil.class,
585                                    "_service");
586                    }
587    
588                    return _service;
589            }
590    
591            /**
592             * @deprecated As of 6.2.0
593             */
594            public void setService(DDMStructureService service) {
595            }
596    
597            private static DDMStructureService _service;
598    }