001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatamapping.service;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.ServiceWrapper;
020    
021    /**
022     * Provides a wrapper for {@link DDMStructureLocalService}.
023     *
024     * @author Brian Wing Shun Chan
025     * @see DDMStructureLocalService
026     * @generated
027     */
028    @ProviderType
029    public class DDMStructureLocalServiceWrapper implements DDMStructureLocalService,
030            ServiceWrapper<DDMStructureLocalService> {
031            public DDMStructureLocalServiceWrapper(
032                    DDMStructureLocalService ddmStructureLocalService) {
033                    _ddmStructureLocalService = ddmStructureLocalService;
034            }
035    
036            /**
037            * Adds the d d m structure to the database. Also notifies the appropriate model listeners.
038            *
039            * @param ddmStructure the d d m structure
040            * @return the d d m structure that was added
041            */
042            @Override
043            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addDDMStructure(
044                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
045                    return _ddmStructureLocalService.addDDMStructure(ddmStructure);
046            }
047    
048            @Override
049            public void addDLFileEntryTypeDDMStructure(long fileEntryTypeId,
050                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
051                    _ddmStructureLocalService.addDLFileEntryTypeDDMStructure(fileEntryTypeId,
052                            ddmStructure);
053            }
054    
055            @Override
056            public void addDLFileEntryTypeDDMStructure(long fileEntryTypeId,
057                    long structureId) {
058                    _ddmStructureLocalService.addDLFileEntryTypeDDMStructure(fileEntryTypeId,
059                            structureId);
060            }
061    
062            @Override
063            public void addDLFileEntryTypeDDMStructures(long fileEntryTypeId,
064                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
065                    _ddmStructureLocalService.addDLFileEntryTypeDDMStructures(fileEntryTypeId,
066                            DDMStructures);
067            }
068    
069            @Override
070            public void addDLFileEntryTypeDDMStructures(long fileEntryTypeId,
071                    long[] structureIds) {
072                    _ddmStructureLocalService.addDLFileEntryTypeDDMStructures(fileEntryTypeId,
073                            structureIds);
074            }
075    
076            @Override
077            public void addJournalFolderDDMStructure(long folderId,
078                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
079                    _ddmStructureLocalService.addJournalFolderDDMStructure(folderId,
080                            ddmStructure);
081            }
082    
083            @Override
084            public void addJournalFolderDDMStructure(long folderId, long structureId) {
085                    _ddmStructureLocalService.addJournalFolderDDMStructure(folderId,
086                            structureId);
087            }
088    
089            @Override
090            public void addJournalFolderDDMStructures(long folderId,
091                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
092                    _ddmStructureLocalService.addJournalFolderDDMStructures(folderId,
093                            DDMStructures);
094            }
095    
096            @Override
097            public void addJournalFolderDDMStructures(long folderId, long[] structureIds) {
098                    _ddmStructureLocalService.addJournalFolderDDMStructures(folderId,
099                            structureIds);
100            }
101    
102            @Override
103            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
104                    long userId, long groupId, long classNameId,
105                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
106                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
107                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
108                    com.liferay.portal.service.ServiceContext serviceContext)
109                    throws com.liferay.portal.kernel.exception.PortalException {
110                    return _ddmStructureLocalService.addStructure(userId, groupId,
111                            classNameId, nameMap, descriptionMap, ddmForm, serviceContext);
112            }
113    
114            /**
115            * Adds a structure referencing a default parent structure, using the portal
116            * property <code>dynamic.data.lists.storage.type</code> storage type and
117            * default structure type.
118            *
119            * @param userId the primary key of the structure's creator/owner
120            * @param groupId the primary key of the group
121            * @param classNameId the primary key of the class name for the
122            structure's related model
123            * @param nameMap the structure's locales and localized names
124            * @param descriptionMap the structure's locales and localized
125            descriptions
126            * @param definition the structure's XML schema definition
127            * @param serviceContext the service context to be applied. Can set the
128            UUID, creation date, modification date, guest permissions,
129            and group permissions for the structure.
130            * @return the structure
131            * @throws PortalException if a user with the primary key could not be
132            found, if the XSD was not well-formed, or if a portal
133            exception occurred
134            * @deprecated As of 7.0.0, replaced by {@link #addStructure(long, long,
135            long, Map, Map, DDMForm, ServiceContext)}
136            */
137            @Deprecated
138            @Override
139            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
140                    long userId, long groupId, long classNameId,
141                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
142                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
143                    java.lang.String definition,
144                    com.liferay.portal.service.ServiceContext serviceContext)
145                    throws com.liferay.portal.kernel.exception.PortalException {
146                    return _ddmStructureLocalService.addStructure(userId, groupId,
147                            classNameId, nameMap, descriptionMap, definition, serviceContext);
148            }
149    
150            @Override
151            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
152                    long userId, long groupId, long parentStructureId, long classNameId,
153                    java.lang.String structureKey,
154                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
155                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
156                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
157                    java.lang.String storageType, int type,
158                    com.liferay.portal.service.ServiceContext serviceContext)
159                    throws com.liferay.portal.kernel.exception.PortalException {
160                    return _ddmStructureLocalService.addStructure(userId, groupId,
161                            parentStructureId, classNameId, structureKey, nameMap,
162                            descriptionMap, ddmForm, storageType, type, serviceContext);
163            }
164    
165            /**
166            * Adds a structure referencing its parent structure.
167            *
168            * @param userId the primary key of the structure's creator/owner
169            * @param groupId the primary key of the group
170            * @param parentStructureId the primary key of the parent structure
171            (optionally {@link
172            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants#DEFAULT_PARENT_STRUCTURE_ID})
173            * @param classNameId the primary key of the class name for the
174            structure's related model
175            * @param structureKey the unique string identifying the structure
176            (optionally <code>null</code>)
177            * @param nameMap the structure's locales and localized names
178            * @param descriptionMap the structure's locales and localized
179            descriptions
180            * @param definition the structure's XML schema definition
181            * @param storageType the structure's storage type. It can be "xml" or
182            "expando". For more information, see {@link
183            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
184            * @param type the structure's type. For more information, see {@link
185            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
186            * @param serviceContext the service context to be applied. Can set the
187            UUID, creation date, modification date, guest permissions,
188            and group permissions for the structure.
189            * @return the structure
190            * @throws PortalException if a user with the primary key could not be
191            found, if the XSD was not well-formed, or if a portal
192            exception occurred
193            * @deprecated As of 7.0.0, replaced by {@link #addStructure(long, long,
194            long, long, String, Map, Map, DDMForm, String, int,
195            ServiceContext)}
196            */
197            @Deprecated
198            @Override
199            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
200                    long userId, long groupId, long parentStructureId, long classNameId,
201                    java.lang.String structureKey,
202                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
203                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
204                    java.lang.String definition, java.lang.String storageType, int type,
205                    com.liferay.portal.service.ServiceContext serviceContext)
206                    throws com.liferay.portal.kernel.exception.PortalException {
207                    return _ddmStructureLocalService.addStructure(userId, groupId,
208                            parentStructureId, classNameId, structureKey, nameMap,
209                            descriptionMap, definition, storageType, type, serviceContext);
210            }
211    
212            @Override
213            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
214                    long userId, long groupId, java.lang.String parentStructureKey,
215                    long classNameId, java.lang.String structureKey,
216                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
217                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
218                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
219                    java.lang.String storageType, int type,
220                    com.liferay.portal.service.ServiceContext serviceContext)
221                    throws com.liferay.portal.kernel.exception.PortalException {
222                    return _ddmStructureLocalService.addStructure(userId, groupId,
223                            parentStructureKey, classNameId, structureKey, nameMap,
224                            descriptionMap, ddmForm, storageType, type, serviceContext);
225            }
226    
227            /**
228            * Adds a structure referencing a default parent structure if the parent
229            * structure is not found.
230            *
231            * @param userId the primary key of the structure's creator/owner
232            * @param groupId the primary key of the group
233            * @param parentStructureKey the unique string identifying the parent
234            structure (optionally <code>null</code>)
235            * @param classNameId the primary key of the class name for the
236            structure's related model
237            * @param structureKey the unique string identifying the structure
238            (optionally <code>null</code>)
239            * @param nameMap the structure's locales and localized names
240            * @param descriptionMap the structure's locales and localized
241            descriptions
242            * @param definition the structure's XML schema definition
243            * @param storageType the structure's storage type. It can be "xml" or
244            "expando". For more information, see {@link
245            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
246            * @param type the structure's type. For more information, see {@link
247            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
248            * @param serviceContext the service context to be applied. Can set the
249            UUID, creation date, modification date, guest permissions and
250            group permissions for the structure.
251            * @return the structure
252            * @throws PortalException if a user with the primary key could not be
253            found, if the XSD was not well-formed, or if a portal
254            exception occurred
255            * @deprecated As of 7.0.0, replaced by {@link #addStructure(long, long,
256            String, long, String, Map, Map, DDMForm, String, int,
257            ServiceContext)}
258            */
259            @Deprecated
260            @Override
261            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
262                    long userId, long groupId, java.lang.String parentStructureKey,
263                    long classNameId, java.lang.String structureKey,
264                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
265                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
266                    java.lang.String definition, java.lang.String storageType, int type,
267                    com.liferay.portal.service.ServiceContext serviceContext)
268                    throws com.liferay.portal.kernel.exception.PortalException {
269                    return _ddmStructureLocalService.addStructure(userId, groupId,
270                            parentStructureKey, classNameId, structureKey, nameMap,
271                            descriptionMap, definition, storageType, type, serviceContext);
272            }
273    
274            /**
275            * Adds the resources to the structure.
276            *
277            * @param structure the structure to add resources to
278            * @param addGroupPermissions whether to add group permissions
279            * @param addGuestPermissions whether to add guest permissions
280            * @throws PortalException if a portal exception occurred
281            */
282            @Override
283            public void addStructureResources(
284                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure,
285                    boolean addGroupPermissions, boolean addGuestPermissions)
286                    throws com.liferay.portal.kernel.exception.PortalException {
287                    _ddmStructureLocalService.addStructureResources(structure,
288                            addGroupPermissions, addGuestPermissions);
289            }
290    
291            /**
292            * Adds the model resources with the permissions to the structure.
293            *
294            * @param structure the structure to add resources to
295            * @param groupPermissions the group permissions to be added
296            * @param guestPermissions the guest permissions to be added
297            * @throws PortalException if a portal exception occurred
298            */
299            @Override
300            public void addStructureResources(
301                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure,
302                    java.lang.String[] groupPermissions, java.lang.String[] guestPermissions)
303                    throws com.liferay.portal.kernel.exception.PortalException {
304                    _ddmStructureLocalService.addStructureResources(structure,
305                            groupPermissions, guestPermissions);
306            }
307    
308            @Override
309            public void clearDLFileEntryTypeDDMStructures(long fileEntryTypeId) {
310                    _ddmStructureLocalService.clearDLFileEntryTypeDDMStructures(fileEntryTypeId);
311            }
312    
313            @Override
314            public void clearJournalFolderDDMStructures(long folderId) {
315                    _ddmStructureLocalService.clearJournalFolderDDMStructures(folderId);
316            }
317    
318            /**
319            * Copies a structure, creating a new structure with all the values
320            * extracted from the original one. The new structure supports a new name
321            * and description.
322            *
323            * @param userId the primary key of the structure's creator/owner
324            * @param structureId the primary key of the structure to be copied
325            * @param nameMap the new structure's locales and localized names
326            * @param descriptionMap the new structure's locales and localized
327            descriptions
328            * @param serviceContext the service context to be applied. Can set the
329            UUID, creation date, modification date, guest permissions, and
330            group permissions for the structure.
331            * @return the new structure
332            * @throws PortalException if a portal exception occurred
333            */
334            @Override
335            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
336                    long userId, long structureId,
337                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
338                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
339                    com.liferay.portal.service.ServiceContext serviceContext)
340                    throws com.liferay.portal.kernel.exception.PortalException {
341                    return _ddmStructureLocalService.copyStructure(userId, structureId,
342                            nameMap, descriptionMap, serviceContext);
343            }
344    
345            @Override
346            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
347                    long userId, long structureId,
348                    com.liferay.portal.service.ServiceContext serviceContext)
349                    throws com.liferay.portal.kernel.exception.PortalException {
350                    return _ddmStructureLocalService.copyStructure(userId, structureId,
351                            serviceContext);
352            }
353    
354            /**
355            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
356            *
357            * @param structureId the primary key for the new d d m structure
358            * @return the new d d m structure
359            */
360            @Override
361            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure createDDMStructure(
362                    long structureId) {
363                    return _ddmStructureLocalService.createDDMStructure(structureId);
364            }
365    
366            /**
367            * Deletes the d d m structure from the database. Also notifies the appropriate model listeners.
368            *
369            * @param ddmStructure the d d m structure
370            * @return the d d m structure that was removed
371            */
372            @Override
373            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure(
374                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
375                    return _ddmStructureLocalService.deleteDDMStructure(ddmStructure);
376            }
377    
378            /**
379            * Deletes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
380            *
381            * @param structureId the primary key of the d d m structure
382            * @return the d d m structure that was removed
383            * @throws PortalException if a d d m structure with the primary key could not be found
384            */
385            @Override
386            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure(
387                    long structureId)
388                    throws com.liferay.portal.kernel.exception.PortalException {
389                    return _ddmStructureLocalService.deleteDDMStructure(structureId);
390            }
391    
392            @Override
393            public void deleteDLFileEntryTypeDDMStructure(long fileEntryTypeId,
394                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
395                    _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructure(fileEntryTypeId,
396                            ddmStructure);
397            }
398    
399            @Override
400            public void deleteDLFileEntryTypeDDMStructure(long fileEntryTypeId,
401                    long structureId) {
402                    _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructure(fileEntryTypeId,
403                            structureId);
404            }
405    
406            @Override
407            public void deleteDLFileEntryTypeDDMStructures(long fileEntryTypeId,
408                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
409                    _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructures(fileEntryTypeId,
410                            DDMStructures);
411            }
412    
413            @Override
414            public void deleteDLFileEntryTypeDDMStructures(long fileEntryTypeId,
415                    long[] structureIds) {
416                    _ddmStructureLocalService.deleteDLFileEntryTypeDDMStructures(fileEntryTypeId,
417                            structureIds);
418            }
419    
420            @Override
421            public void deleteJournalFolderDDMStructure(long folderId,
422                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
423                    _ddmStructureLocalService.deleteJournalFolderDDMStructure(folderId,
424                            ddmStructure);
425            }
426    
427            @Override
428            public void deleteJournalFolderDDMStructure(long folderId, long structureId) {
429                    _ddmStructureLocalService.deleteJournalFolderDDMStructure(folderId,
430                            structureId);
431            }
432    
433            @Override
434            public void deleteJournalFolderDDMStructures(long folderId,
435                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> DDMStructures) {
436                    _ddmStructureLocalService.deleteJournalFolderDDMStructures(folderId,
437                            DDMStructures);
438            }
439    
440            @Override
441            public void deleteJournalFolderDDMStructures(long folderId,
442                    long[] structureIds) {
443                    _ddmStructureLocalService.deleteJournalFolderDDMStructures(folderId,
444                            structureIds);
445            }
446    
447            /**
448            * @throws PortalException
449            */
450            @Override
451            public com.liferay.portal.model.PersistedModel deletePersistedModel(
452                    com.liferay.portal.model.PersistedModel persistedModel)
453                    throws com.liferay.portal.kernel.exception.PortalException {
454                    return _ddmStructureLocalService.deletePersistedModel(persistedModel);
455            }
456    
457            /**
458            * Deletes the matching structure and its resources.
459            *
460            * <p>
461            * Before deleting the structure, the system verifies whether the structure
462            * is required by another entity. If it is needed, an exception is thrown.
463            * </p>
464            *
465            * @param groupId the primary key of the group
466            * @param classNameId the primary key of the class name for the structure's
467            related model
468            * @param structureKey the unique string identifying the structure
469            * @throws PortalException if a portal exception occurred
470            */
471            @Override
472            public void deleteStructure(long groupId, long classNameId,
473                    java.lang.String structureKey)
474                    throws com.liferay.portal.kernel.exception.PortalException {
475                    _ddmStructureLocalService.deleteStructure(groupId, classNameId,
476                            structureKey);
477            }
478    
479            /**
480            * Deletes the structure and its resources.
481            *
482            * <p>
483            * Before deleting the structure, this method verifies whether the structure
484            * is required by another entity. If it is needed, an exception is thrown.
485            * </p>
486            *
487            * @param structure the structure to be deleted
488            * @throws PortalException if a portal exception occurred
489            */
490            @Override
491            public void deleteStructure(
492                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure)
493                    throws com.liferay.portal.kernel.exception.PortalException {
494                    _ddmStructureLocalService.deleteStructure(structure);
495            }
496    
497            /**
498            * Deletes the structure and its resources.
499            *
500            * <p>
501            * Before deleting the structure, the system verifies whether the structure
502            * is required by another entity. If it is needed, an exception is thrown.
503            * </p>
504            *
505            * @param structureId the primary key of the structure to be deleted
506            * @throws PortalException if a portal exception occurred
507            */
508            @Override
509            public void deleteStructure(long structureId)
510                    throws com.liferay.portal.kernel.exception.PortalException {
511                    _ddmStructureLocalService.deleteStructure(structureId);
512            }
513    
514            /**
515            * Deletes all the structures of the group.
516            *
517            * <p>
518            * Before deleting the structures, the system verifies whether each
519            * structure is required by another entity. If any of the structures are
520            * needed, an exception is thrown.
521            * </p>
522            *
523            * @param groupId the primary key of the group
524            * @throws PortalException if a portal exception occurred
525            */
526            @Override
527            public void deleteStructures(long groupId)
528                    throws com.liferay.portal.kernel.exception.PortalException {
529                    _ddmStructureLocalService.deleteStructures(groupId);
530            }
531    
532            @Override
533            public void deleteStructures(long groupId, long classNameId)
534                    throws com.liferay.portal.kernel.exception.PortalException {
535                    _ddmStructureLocalService.deleteStructures(groupId, classNameId);
536            }
537    
538            @Override
539            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
540                    return _ddmStructureLocalService.dynamicQuery();
541            }
542    
543            /**
544            * Performs a dynamic query on the database and returns the matching rows.
545            *
546            * @param dynamicQuery the dynamic query
547            * @return the matching rows
548            */
549            @Override
550            public <T> java.util.List<T> dynamicQuery(
551                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
552                    return _ddmStructureLocalService.dynamicQuery(dynamicQuery);
553            }
554    
555            /**
556            * Performs a dynamic query on the database and returns a range of the matching rows.
557            *
558            * <p>
559            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
560            * </p>
561            *
562            * @param dynamicQuery the dynamic query
563            * @param start the lower bound of the range of model instances
564            * @param end the upper bound of the range of model instances (not inclusive)
565            * @return the range of matching rows
566            */
567            @Override
568            public <T> java.util.List<T> dynamicQuery(
569                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
570                    int end) {
571                    return _ddmStructureLocalService.dynamicQuery(dynamicQuery, start, end);
572            }
573    
574            /**
575            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
576            *
577            * <p>
578            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
579            * </p>
580            *
581            * @param dynamicQuery the dynamic query
582            * @param start the lower bound of the range of model instances
583            * @param end the upper bound of the range of model instances (not inclusive)
584            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
585            * @return the ordered range of matching rows
586            */
587            @Override
588            public <T> java.util.List<T> dynamicQuery(
589                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
590                    int end,
591                    com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) {
592                    return _ddmStructureLocalService.dynamicQuery(dynamicQuery, start, end,
593                            orderByComparator);
594            }
595    
596            /**
597            * Returns the number of rows matching the dynamic query.
598            *
599            * @param dynamicQuery the dynamic query
600            * @return the number of rows matching the dynamic query
601            */
602            @Override
603            public long dynamicQueryCount(
604                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) {
605                    return _ddmStructureLocalService.dynamicQueryCount(dynamicQuery);
606            }
607    
608            /**
609            * Returns the number of rows matching the dynamic query.
610            *
611            * @param dynamicQuery the dynamic query
612            * @param projection the projection to apply to the query
613            * @return the number of rows matching the dynamic query
614            */
615            @Override
616            public long dynamicQueryCount(
617                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery,
618                    com.liferay.portal.kernel.dao.orm.Projection projection) {
619                    return _ddmStructureLocalService.dynamicQueryCount(dynamicQuery,
620                            projection);
621            }
622    
623            @Override
624            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructure(
625                    long structureId) {
626                    return _ddmStructureLocalService.fetchDDMStructure(structureId);
627            }
628    
629            /**
630            * Returns the d d m structure matching the UUID and group.
631            *
632            * @param uuid the d d m structure's UUID
633            * @param groupId the primary key of the group
634            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
635            */
636            @Override
637            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructureByUuidAndGroupId(
638                    java.lang.String uuid, long groupId) {
639                    return _ddmStructureLocalService.fetchDDMStructureByUuidAndGroupId(uuid,
640                            groupId);
641            }
642    
643            /**
644            * Returns the structure matching the class name ID, structure key, and
645            * group.
646            *
647            * @param groupId the primary key of the group
648            * @param classNameId the primary key of the class name for the structure's
649            related model
650            * @param structureKey the unique string identifying the structure
651            * @return the matching structure, or <code>null</code> if a matching
652            structure could not be found
653            */
654            @Override
655            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
656                    long groupId, long classNameId, java.lang.String structureKey) {
657                    return _ddmStructureLocalService.fetchStructure(groupId, classNameId,
658                            structureKey);
659            }
660    
661            /**
662            * Returns the structure matching the class name ID, structure key, and
663            * group, optionally searching ancestor sites (that have sharing enabled)
664            * and global scoped sites.
665            *
666            * <p>
667            * This method first searches in the group. If the structure is still not
668            * found and <code>includeAncestorStructures</code> is set to
669            * <code>true</code>, this method searches the group's ancestor sites (that
670            * have sharing enabled) and lastly searches global scoped sites.
671            * </p>
672            *
673            * @param groupId the primary key of the group
674            * @param classNameId the primary key of the class name for the structure's
675            related model
676            * @param structureKey the unique string identifying the structure
677            * @param includeAncestorStructures whether to include ancestor sites (that
678            have sharing enabled) and include global scoped sites in the
679            search
680            * @return the matching structure, or <code>null</code> if a matching
681            structure could not be found
682            * @throws PortalException if a portal exception occurred
683            */
684            @Override
685            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
686                    long groupId, long classNameId, java.lang.String structureKey,
687                    boolean includeAncestorStructures)
688                    throws com.liferay.portal.kernel.exception.PortalException {
689                    return _ddmStructureLocalService.fetchStructure(groupId, classNameId,
690                            structureKey, includeAncestorStructures);
691            }
692    
693            /**
694            * Returns the structure with the ID.
695            *
696            * @param structureId the primary key of the structure
697            * @return the structure with the structure ID, or <code>null</code> if a
698            matching structure could not be found
699            */
700            @Override
701            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
702                    long structureId) {
703                    return _ddmStructureLocalService.fetchStructure(structureId);
704            }
705    
706            @Override
707            public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() {
708                    return _ddmStructureLocalService.getActionableDynamicQuery();
709            }
710    
711            /**
712            * Returns the Spring bean ID for this bean.
713            *
714            * @return the Spring bean ID for this bean
715            */
716            @Override
717            public java.lang.String getBeanIdentifier() {
718                    return _ddmStructureLocalService.getBeanIdentifier();
719            }
720    
721            /**
722            * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long,
723            long)}
724            */
725            @Deprecated
726            @Override
727            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
728                    long classNameId) {
729                    return _ddmStructureLocalService.getClassStructures(classNameId);
730            }
731    
732            /**
733            * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long,
734            long, OrderByComparator)}
735            */
736            @Deprecated
737            @Override
738            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
739                    long classNameId,
740                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
741                    return _ddmStructureLocalService.getClassStructures(classNameId,
742                            orderByComparator);
743            }
744    
745            /**
746            * @deprecated As of 6.2.0, replaced by {@link #getClassStructures(long,
747            long, int, int)}
748            */
749            @Deprecated
750            @Override
751            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
752                    long classNameId, int start, int end) {
753                    return _ddmStructureLocalService.getClassStructures(classNameId, start,
754                            end);
755            }
756    
757            /**
758            * Returns all the structures matching the class name ID.
759            *
760            * @param companyId the primary key of the structure's company
761            * @param classNameId the primary key of the class name for the structure's
762            related model
763            * @return the structures matching the class name ID
764            */
765            @Override
766            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
767                    long companyId, long classNameId) {
768                    return _ddmStructureLocalService.getClassStructures(companyId,
769                            classNameId);
770            }
771    
772            /**
773            * Returns all the structures matching the class name ID ordered by the
774            * comparator.
775            *
776            * @param companyId the primary key of the structure's company
777            * @param classNameId the primary key of the class name for the structure's
778            related model
779            * @param orderByComparator the comparator to order the structures
780            (optionally <code>null</code>)
781            * @return the matching structures ordered by the comparator
782            */
783            @Override
784            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
785                    long companyId, long classNameId,
786                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
787                    return _ddmStructureLocalService.getClassStructures(companyId,
788                            classNameId, orderByComparator);
789            }
790    
791            /**
792            * Returns a range of all the structures matching the class name ID.
793            *
794            * <p>
795            * Useful when paginating results. Returns a maximum of <code>end -
796            * start</code> instances. <code>start</code> and <code>end</code> are not
797            * primary keys, they are indexes in the result set. Thus, <code>0</code>
798            * refers to the first result in the set. Setting both <code>start</code>
799            * and <code>end</code> to {@link
800            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
801            * result set.
802            * </p>
803            *
804            * @param companyId the primary key of the structure's company
805            * @param classNameId the primary key of the class name for the structure's
806            related model
807            * @param start the lower bound of the range of structures to return
808            * @param end the upper bound of the range of structures to return (not
809            inclusive)
810            * @return the range of matching structures
811            */
812            @Override
813            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
814                    long companyId, long classNameId, int start, int end) {
815                    return _ddmStructureLocalService.getClassStructures(companyId,
816                            classNameId, start, end);
817            }
818    
819            /**
820            * Returns the d d m structure with the primary key.
821            *
822            * @param structureId the primary key of the d d m structure
823            * @return the d d m structure
824            * @throws PortalException if a d d m structure with the primary key could not be found
825            */
826            @Override
827            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructure(
828                    long structureId)
829                    throws com.liferay.portal.kernel.exception.PortalException {
830                    return _ddmStructureLocalService.getDDMStructure(structureId);
831            }
832    
833            /**
834            * Returns the d d m structure matching the UUID and group.
835            *
836            * @param uuid the d d m structure's UUID
837            * @param groupId the primary key of the group
838            * @return the matching d d m structure
839            * @throws PortalException if a matching d d m structure could not be found
840            */
841            @Override
842            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructureByUuidAndGroupId(
843                    java.lang.String uuid, long groupId)
844                    throws com.liferay.portal.kernel.exception.PortalException {
845                    return _ddmStructureLocalService.getDDMStructureByUuidAndGroupId(uuid,
846                            groupId);
847            }
848    
849            /**
850            * Returns a range of all the d d m structures.
851            *
852            * <p>
853            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. 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.
854            * </p>
855            *
856            * @param start the lower bound of the range of d d m structures
857            * @param end the upper bound of the range of d d m structures (not inclusive)
858            * @return the range of d d m structures
859            */
860            @Override
861            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
862                    int start, int end) {
863                    return _ddmStructureLocalService.getDDMStructures(start, end);
864            }
865    
866            /**
867            * Returns all the d d m structures matching the UUID and company.
868            *
869            * @param uuid the UUID of the d d m structures
870            * @param companyId the primary key of the company
871            * @return the matching d d m structures, or an empty list if no matches were found
872            */
873            @Override
874            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructuresByUuidAndCompanyId(
875                    java.lang.String uuid, long companyId) {
876                    return _ddmStructureLocalService.getDDMStructuresByUuidAndCompanyId(uuid,
877                            companyId);
878            }
879    
880            /**
881            * Returns a range of d d m structures matching the UUID and company.
882            *
883            * @param uuid the UUID of the d d m structures
884            * @param companyId the primary key of the company
885            * @param start the lower bound of the range of d d m structures
886            * @param end the upper bound of the range of d d m structures (not inclusive)
887            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
888            * @return the range of matching d d m structures, or an empty list if no matches were found
889            */
890            @Override
891            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructuresByUuidAndCompanyId(
892                    java.lang.String uuid, long companyId, int start, int end,
893                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
894                    return _ddmStructureLocalService.getDDMStructuresByUuidAndCompanyId(uuid,
895                            companyId, start, end, orderByComparator);
896            }
897    
898            /**
899            * Returns the number of d d m structures.
900            *
901            * @return the number of d d m structures
902            */
903            @Override
904            public int getDDMStructuresCount() {
905                    return _ddmStructureLocalService.getDDMStructuresCount();
906            }
907    
908            @Override
909            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures(
910                    long fileEntryTypeId) {
911                    return _ddmStructureLocalService.getDLFileEntryTypeDDMStructures(fileEntryTypeId);
912            }
913    
914            @Override
915            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures(
916                    long fileEntryTypeId, int start, int end) {
917                    return _ddmStructureLocalService.getDLFileEntryTypeDDMStructures(fileEntryTypeId,
918                            start, end);
919            }
920    
921            @Override
922            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeDDMStructures(
923                    long fileEntryTypeId, int start, int end,
924                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
925                    return _ddmStructureLocalService.getDLFileEntryTypeDDMStructures(fileEntryTypeId,
926                            start, end, orderByComparator);
927            }
928    
929            @Override
930            public int getDLFileEntryTypeDDMStructuresCount(long fileEntryTypeId) {
931                    return _ddmStructureLocalService.getDLFileEntryTypeDDMStructuresCount(fileEntryTypeId);
932            }
933    
934            /**
935            * Returns the fileEntryTypeIds of the document library file entry types associated with the d d m structure.
936            *
937            * @param structureId the structureId of the d d m structure
938            * @return long[] the fileEntryTypeIds of document library file entry types associated with the d d m structure
939            */
940            @Override
941            public long[] getDLFileEntryTypePrimaryKeys(long structureId) {
942                    return _ddmStructureLocalService.getDLFileEntryTypePrimaryKeys(structureId);
943            }
944    
945            /**
946            * Returns all the structures for the document library file entry type.
947            *
948            * @param dlFileEntryTypeId the primary key of the document library file
949            entry type
950            * @return the structures for the document library file entry type
951            */
952            @Override
953            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeStructures(
954                    long dlFileEntryTypeId) {
955                    return _ddmStructureLocalService.getDLFileEntryTypeStructures(dlFileEntryTypeId);
956            }
957    
958            @Override
959            public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery(
960                    com.liferay.portal.kernel.lar.PortletDataContext portletDataContext) {
961                    return _ddmStructureLocalService.getExportActionableDynamicQuery(portletDataContext);
962            }
963    
964            @Override
965            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures(
966                    long folderId) {
967                    return _ddmStructureLocalService.getJournalFolderDDMStructures(folderId);
968            }
969    
970            @Override
971            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures(
972                    long folderId, int start, int end) {
973                    return _ddmStructureLocalService.getJournalFolderDDMStructures(folderId,
974                            start, end);
975            }
976    
977            @Override
978            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderDDMStructures(
979                    long folderId, int start, int end,
980                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
981                    return _ddmStructureLocalService.getJournalFolderDDMStructures(folderId,
982                            start, end, orderByComparator);
983            }
984    
985            @Override
986            public int getJournalFolderDDMStructuresCount(long folderId) {
987                    return _ddmStructureLocalService.getJournalFolderDDMStructuresCount(folderId);
988            }
989    
990            /**
991            * Returns the folderIds of the journal folders associated with the d d m structure.
992            *
993            * @param structureId the structureId of the d d m structure
994            * @return long[] the folderIds of journal folders associated with the d d m structure
995            */
996            @Override
997            public long[] getJournalFolderPrimaryKeys(long structureId) {
998                    return _ddmStructureLocalService.getJournalFolderPrimaryKeys(structureId);
999            }
1000    
1001            @Override
1002            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getJournalFolderStructures(
1003                    long[] groupIds, long journalFolderId, int restrictionType)
1004                    throws com.liferay.portal.kernel.exception.PortalException {
1005                    return _ddmStructureLocalService.getJournalFolderStructures(groupIds,
1006                            journalFolderId, restrictionType);
1007            }
1008    
1009            @Override
1010            public com.liferay.portal.model.PersistedModel getPersistedModel(
1011                    java.io.Serializable primaryKeyObj)
1012                    throws com.liferay.portal.kernel.exception.PortalException {
1013                    return _ddmStructureLocalService.getPersistedModel(primaryKeyObj);
1014            }
1015    
1016            /**
1017            * Returns the structure matching the class name ID, structure key, and
1018            * group.
1019            *
1020            * @param groupId the primary key of the structure's group
1021            * @param classNameId the primary key of the class name for the structure's
1022            related model
1023            * @param structureKey the unique string identifying the structure
1024            * @return the matching structure
1025            * @throws PortalException if a matching structure could not be found
1026            */
1027            @Override
1028            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
1029                    long groupId, long classNameId, java.lang.String structureKey)
1030                    throws com.liferay.portal.kernel.exception.PortalException {
1031                    return _ddmStructureLocalService.getStructure(groupId, classNameId,
1032                            structureKey);
1033            }
1034    
1035            /**
1036            * Returns the structure matching the class name ID, structure key, and
1037            * group, optionally searching ancestor sites (that have sharing enabled)
1038            * and global scoped sites.
1039            *
1040            * <p>
1041            * This method first searches in the group. If the structure is still not
1042            * found and <code>includeAncestorStructures</code> is set to
1043            * <code>true</code>, this method searches the group's ancestor sites (that
1044            * have sharing enabled) and lastly searches global scoped sites.
1045            * </p>
1046            *
1047            * @param groupId the primary key of the structure's group
1048            * @param classNameId the primary key of the class name for the structure's
1049            related model
1050            * @param structureKey the unique string identifying the structure
1051            * @param includeAncestorStructures whether to include ancestor sites (that
1052            have sharing enabled) and include global scoped sites in the
1053            search in the search
1054            * @return the matching structure
1055            * @throws PortalException if a matching structure could not be found
1056            */
1057            @Override
1058            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
1059                    long groupId, long classNameId, java.lang.String structureKey,
1060                    boolean includeAncestorStructures)
1061                    throws com.liferay.portal.kernel.exception.PortalException {
1062                    return _ddmStructureLocalService.getStructure(groupId, classNameId,
1063                            structureKey, includeAncestorStructures);
1064            }
1065    
1066            /**
1067            * Returns all the structures matching the group, name, and description.
1068            *
1069            * @param groupId the primary key of the structure's group
1070            * @param name the structure's name
1071            * @param description the structure's description
1072            * @return the matching structures
1073            */
1074            @Override
1075            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructure(
1076                    long groupId, java.lang.String name, java.lang.String description) {
1077                    return _ddmStructureLocalService.getStructure(groupId, name, description);
1078            }
1079    
1080            /**
1081            * Returns the structure with the ID.
1082            *
1083            * @param structureId the primary key of the structure
1084            * @return the structure with the ID
1085            * @throws PortalException if a structure with the ID could not be found
1086            */
1087            @Override
1088            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
1089                    long structureId)
1090                    throws com.liferay.portal.kernel.exception.PortalException {
1091                    return _ddmStructureLocalService.getStructure(structureId);
1092            }
1093    
1094            /**
1095            * @deprecated As of 6.2.0, replaced by {@link #getStructures}
1096            */
1097            @Deprecated
1098            @Override
1099            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries() {
1100                    return _ddmStructureLocalService.getStructureEntries();
1101            }
1102    
1103            /**
1104            * @deprecated As of 6.2.0, replaced by {@link #getStructures(long)}
1105            */
1106            @Deprecated
1107            @Override
1108            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries(
1109                    long groupId) {
1110                    return _ddmStructureLocalService.getStructureEntries(groupId);
1111            }
1112    
1113            /**
1114            * @deprecated As of 6.2.0, replaced by {@link #getStructures(long, int,
1115            int)}
1116            */
1117            @Deprecated
1118            @Override
1119            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries(
1120                    long groupId, int start, int end) {
1121                    return _ddmStructureLocalService.getStructureEntries(groupId, start, end);
1122            }
1123    
1124            /**
1125            * Returns all the structures present in the system.
1126            *
1127            * @return the structures present in the system
1128            */
1129            @Override
1130            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures() {
1131                    return _ddmStructureLocalService.getStructures();
1132            }
1133    
1134            /**
1135            * Returns all the structures present in the group.
1136            *
1137            * @param groupId the primary key of the group
1138            * @return the structures present in the group
1139            */
1140            @Override
1141            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1142                    long groupId) {
1143                    return _ddmStructureLocalService.getStructures(groupId);
1144            }
1145    
1146            /**
1147            * Returns all the structures matching class name ID and group.
1148            *
1149            * @param groupId the primary key of the group
1150            * @param classNameId the primary key of the class name for the structure's
1151            related model
1152            * @return the matching structures
1153            */
1154            @Override
1155            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1156                    long groupId, long classNameId) {
1157                    return _ddmStructureLocalService.getStructures(groupId, classNameId);
1158            }
1159    
1160            /**
1161            * Returns a range of all the structures that match the class name ID and
1162            * group.
1163            *
1164            * <p>
1165            * Useful when paginating results. Returns a maximum of <code>end -
1166            * start</code> instances. <code>start</code> and <code>end</code> are not
1167            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1168            * refers to the first result in the set. Setting both <code>start</code>
1169            * and <code>end</code> to {@link
1170            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1171            * result set.
1172            * </p>
1173            *
1174            * @param groupId the primary key of the group
1175            * @param classNameId the primary key of the class name for the structure's
1176            related model
1177            * @param start the lower bound of the range of structures to return
1178            * @param end the upper bound of the range of structures to return (not
1179            inclusive)
1180            * @return the range of matching structures
1181            */
1182            @Override
1183            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1184                    long groupId, long classNameId, int start, int end) {
1185                    return _ddmStructureLocalService.getStructures(groupId, classNameId,
1186                            start, end);
1187            }
1188    
1189            /**
1190            * Returns an ordered range of all the structures matching the class name ID
1191            * and group.
1192            *
1193            * <p>
1194            * Useful when paginating results. Returns a maximum of <code>end -
1195            * start</code> instances. <code>start</code> and <code>end</code> are not
1196            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1197            * refers to the first result in the set. Setting both <code>start</code>
1198            * and <code>end</code> to {@link
1199            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1200            * result set.
1201            * </p>
1202            *
1203            * @param groupId the primary key of the group
1204            * @param classNameId the primary key of the class name for the structure's
1205            related model
1206            * @param start the lower bound of the range of structures to return
1207            * @param end the upper bound of the range of structures to return (not
1208            inclusive)
1209            * @param orderByComparator the comparator to order the structures
1210            (optionally <code>null</code>)
1211            * @return the range of matching structures ordered by the comparator
1212            */
1213            @Override
1214            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1215                    long groupId, long classNameId, int start, int end,
1216                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1217                    return _ddmStructureLocalService.getStructures(groupId, classNameId,
1218                            start, end, orderByComparator);
1219            }
1220    
1221            @Override
1222            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1223                    long groupId, java.lang.String name, java.lang.String description) {
1224                    return _ddmStructureLocalService.getStructures(groupId, name,
1225                            description);
1226            }
1227    
1228            /**
1229            * Returns a range of all the structures belonging to the group.
1230            *
1231            * <p>
1232            * Useful when paginating results. Returns a maximum of <code>end -
1233            * start</code> instances. <code>start</code> and <code>end</code> are not
1234            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1235            * refers to the first result in the set. Setting both <code>start</code>
1236            * and <code>end</code> to {@link
1237            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1238            * result set.
1239            * </p>
1240            *
1241            * @param groupId the primary key of the group
1242            * @param start the lower bound of the range of structures to return
1243            * @param end the upper bound of the range of structures to return (not
1244            inclusive)
1245            * @return the range of matching structures
1246            */
1247            @Override
1248            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1249                    long groupId, int start, int end) {
1250                    return _ddmStructureLocalService.getStructures(groupId, start, end);
1251            }
1252    
1253            /**
1254            * Returns all the structures belonging to the groups.
1255            *
1256            * @param groupIds the primary keys of the groups
1257            * @return the structures belonging to the groups
1258            */
1259            @Override
1260            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1261                    long[] groupIds) {
1262                    return _ddmStructureLocalService.getStructures(groupIds);
1263            }
1264    
1265            /**
1266            * Returns all the structures matching the class name ID and belonging to
1267            * the groups.
1268            *
1269            * @param groupIds the primary keys of the groups
1270            * @param classNameId the primary key of the class name for the structure's
1271            related model
1272            * @return the matching structures
1273            */
1274            @Override
1275            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1276                    long[] groupIds, long classNameId) {
1277                    return _ddmStructureLocalService.getStructures(groupIds, classNameId);
1278            }
1279    
1280            /**
1281            * Returns a range of all the structures matching the class name ID and
1282            * belonging to the groups.
1283            *
1284            * <p>
1285            * Useful when paginating results. Returns a maximum of <code>end -
1286            * start</code> instances. <code>start</code> and <code>end</code> are not
1287            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1288            * refers to the first result in the set. Setting both <code>start</code>
1289            * and <code>end</code> to {@link
1290            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1291            * result set.
1292            * </p>
1293            *
1294            * @param groupIds the primary keys of the groups
1295            * @param classNameId the primary key of the class name for the structure's
1296            related model
1297            * @param start the lower bound of the range of structures to return
1298            * @param end the upper bound of the range of structures to return (not
1299            inclusive)
1300            * @return the range of matching structures
1301            */
1302            @Override
1303            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
1304                    long[] groupIds, long classNameId, int start, int end) {
1305                    return _ddmStructureLocalService.getStructures(groupIds, classNameId,
1306                            start, end);
1307            }
1308    
1309            /**
1310            * Returns the number of structures belonging to the group.
1311            *
1312            * @param groupId the primary key of the group
1313            * @return the number of structures belonging to the group
1314            */
1315            @Override
1316            public int getStructuresCount(long groupId) {
1317                    return _ddmStructureLocalService.getStructuresCount(groupId);
1318            }
1319    
1320            /**
1321            * Returns the number of structures matching the class name ID and group.
1322            *
1323            * @param groupId the primary key of the group
1324            * @param classNameId the primary key of the class name for the structure's
1325            related model
1326            * @return the number of matching structures
1327            */
1328            @Override
1329            public int getStructuresCount(long groupId, long classNameId) {
1330                    return _ddmStructureLocalService.getStructuresCount(groupId, classNameId);
1331            }
1332    
1333            /**
1334            * Returns the number of structures matching the class name ID and belonging
1335            * to the groups.
1336            *
1337            * @param groupIds the primary keys of the groups
1338            * @param classNameId the primary key of the class name for the structure's
1339            related model
1340            * @return the number of matching structures
1341            */
1342            @Override
1343            public int getStructuresCount(long[] groupIds, long classNameId) {
1344                    return _ddmStructureLocalService.getStructuresCount(groupIds,
1345                            classNameId);
1346            }
1347    
1348            @Override
1349            public boolean hasDLFileEntryTypeDDMStructure(long fileEntryTypeId,
1350                    long structureId) {
1351                    return _ddmStructureLocalService.hasDLFileEntryTypeDDMStructure(fileEntryTypeId,
1352                            structureId);
1353            }
1354    
1355            @Override
1356            public boolean hasDLFileEntryTypeDDMStructures(long fileEntryTypeId) {
1357                    return _ddmStructureLocalService.hasDLFileEntryTypeDDMStructures(fileEntryTypeId);
1358            }
1359    
1360            @Override
1361            public boolean hasJournalFolderDDMStructure(long folderId, long structureId) {
1362                    return _ddmStructureLocalService.hasJournalFolderDDMStructure(folderId,
1363                            structureId);
1364            }
1365    
1366            @Override
1367            public boolean hasJournalFolderDDMStructures(long folderId) {
1368                    return _ddmStructureLocalService.hasJournalFolderDDMStructures(folderId);
1369            }
1370    
1371            /**
1372            * Returns an ordered range of all the structures matching the groups and
1373            * class name IDs, and matching the keywords in the structure names and
1374            * descriptions.
1375            *
1376            * <p>
1377            * Useful when paginating results. Returns a maximum of <code>end -
1378            * start</code> instances. <code>start</code> and <code>end</code> are not
1379            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1380            * refers to the first result in the set. Setting both <code>start</code>
1381            * and <code>end</code> to {@link
1382            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1383            * result set.
1384            * </p>
1385            *
1386            * @param companyId the primary key of the structure's company
1387            * @param groupIds the primary keys of the groups
1388            * @param classNameIds the primary keys of the class names of the models
1389            the structures are related to
1390            * @param keywords the keywords (space separated), which may occur in the
1391            structure's name or description (optionally <code>null</code>)
1392            * @param start the lower bound of the range of structures to return
1393            * @param end the upper bound of the range of structures to return (not
1394            inclusive)
1395            * @param orderByComparator the comparator to order the structures
1396            (optionally <code>null</code>)
1397            * @return the range of matching structures ordered by the comparator
1398            */
1399            @Override
1400            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
1401                    long companyId, long[] groupIds, long[] classNameIds,
1402                    java.lang.String keywords, int start, int end,
1403                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1404                    return _ddmStructureLocalService.search(companyId, groupIds,
1405                            classNameIds, keywords, start, end, orderByComparator);
1406            }
1407    
1408            /**
1409            * Returns an ordered range of all the structures matching the groups, class
1410            * name IDs, name keyword, description keyword, storage type, and type.
1411            *
1412            * <p>
1413            * Useful when paginating results. Returns a maximum of <code>end -
1414            * start</code> instances. <code>start</code> and <code>end</code> are not
1415            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1416            * refers to the first result in the set. Setting both <code>start</code>
1417            * and <code>end</code> to {@link
1418            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1419            * result set.
1420            * </p>
1421            *
1422            * @param companyId the primary key of the structure's company
1423            * @param groupIds the primary keys of the groups
1424            * @param classNameIds the primary keys of the class names of the models
1425            the structures are related to
1426            * @param name the name keywords
1427            * @param description the description keywords
1428            * @param storageType the structure's storage type. It can be "xml" or
1429            "expando". For more information, see {@link
1430            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
1431            * @param type the structure's type. For more information, see {@link
1432            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
1433            * @param andOperator whether every field must match its keywords, or just
1434            one field
1435            * @param start the lower bound of the range of structures to return
1436            * @param end the upper bound of the range of structures to return (not
1437            inclusive)
1438            * @param orderByComparator the comparator to order the structures
1439            (optionally <code>null</code>)
1440            * @return the range of matching structures ordered by the comparator
1441            */
1442            @Override
1443            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
1444                    long companyId, long[] groupIds, long[] classNameIds,
1445                    java.lang.String name, java.lang.String description,
1446                    java.lang.String storageType, int type, boolean andOperator, int start,
1447                    int end,
1448                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator) {
1449                    return _ddmStructureLocalService.search(companyId, groupIds,
1450                            classNameIds, name, description, storageType, type, andOperator,
1451                            start, end, orderByComparator);
1452            }
1453    
1454            /**
1455            * Returns the number of structures matching the groups and class name IDs,
1456            * and matching the keywords in the structure names and descriptions.
1457            *
1458            * @param companyId the primary key of the structure's company
1459            * @param groupIds the primary keys of the groups
1460            * @param classNameIds the primary keys of the class names of the models
1461            the structures are related to
1462            * @param keywords the keywords (space separated), which may occur in the
1463            structure's name or description (optionally <code>null</code>)
1464            * @return the number of matching structures
1465            */
1466            @Override
1467            public int searchCount(long companyId, long[] groupIds,
1468                    long[] classNameIds, java.lang.String keywords) {
1469                    return _ddmStructureLocalService.searchCount(companyId, groupIds,
1470                            classNameIds, keywords);
1471            }
1472    
1473            /**
1474            * Returns the number of structures matching the groups, class name IDs,
1475            * name keyword, description keyword, storage type, and type
1476            *
1477            * @param companyId the primary key of the structure's company
1478            * @param groupIds the primary keys of the groups
1479            * @param classNameIds the primary keys of the class names of the models
1480            the structure's are related to
1481            * @param name the name keywords
1482            * @param description the description keywords
1483            * @param storageType the structure's storage type. It can be "xml" or
1484            "expando". For more information, see {@link
1485            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
1486            * @param type the structure's type. For more information, see {@link
1487            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
1488            * @param andOperator whether every field must match its keywords, or just
1489            one field
1490            * @return the number of matching structures
1491            */
1492            @Override
1493            public int searchCount(long companyId, long[] groupIds,
1494                    long[] classNameIds, java.lang.String name,
1495                    java.lang.String description, java.lang.String storageType, int type,
1496                    boolean andOperator) {
1497                    return _ddmStructureLocalService.searchCount(companyId, groupIds,
1498                            classNameIds, name, description, storageType, type, andOperator);
1499            }
1500    
1501            /**
1502            * Sets the Spring bean ID for this bean.
1503            *
1504            * @param beanIdentifier the Spring bean ID for this bean
1505            */
1506            @Override
1507            public void setBeanIdentifier(java.lang.String beanIdentifier) {
1508                    _ddmStructureLocalService.setBeanIdentifier(beanIdentifier);
1509            }
1510    
1511            @Override
1512            public void setDLFileEntryTypeDDMStructures(long fileEntryTypeId,
1513                    long[] structureIds) {
1514                    _ddmStructureLocalService.setDLFileEntryTypeDDMStructures(fileEntryTypeId,
1515                            structureIds);
1516            }
1517    
1518            @Override
1519            public void setJournalFolderDDMStructures(long folderId, long[] structureIds) {
1520                    _ddmStructureLocalService.setJournalFolderDDMStructures(folderId,
1521                            structureIds);
1522            }
1523    
1524            @Override
1525            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDDMForm(
1526                    long structureId,
1527                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
1528                    com.liferay.portal.service.ServiceContext serviceContext)
1529                    throws com.liferay.portal.kernel.exception.PortalException {
1530                    return _ddmStructureLocalService.updateDDMForm(structureId, ddmForm,
1531                            serviceContext);
1532            }
1533    
1534            /**
1535            * Updates the d d m structure in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
1536            *
1537            * @param ddmStructure the d d m structure
1538            * @return the d d m structure that was updated
1539            */
1540            @Override
1541            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDDMStructure(
1542                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
1543                    return _ddmStructureLocalService.updateDDMStructure(ddmStructure);
1544            }
1545    
1546            @Override
1547            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1548                    long groupId, long parentStructureId, long classNameId,
1549                    java.lang.String structureKey,
1550                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1551                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1552                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
1553                    com.liferay.portal.service.ServiceContext serviceContext)
1554                    throws com.liferay.portal.kernel.exception.PortalException {
1555                    return _ddmStructureLocalService.updateStructure(groupId,
1556                            parentStructureId, classNameId, structureKey, nameMap,
1557                            descriptionMap, ddmForm, serviceContext);
1558            }
1559    
1560            /**
1561            * Updates the structure matching the class name ID, structure key, and
1562            * group, replacing its old parent structure, name map, description map, and
1563            * XSD with new ones.
1564            *
1565            * @param groupId the primary key of the group
1566            * @param parentStructureId the primary key of the new parent structure
1567            * @param classNameId the primary key of the class name for the
1568            structure's related model
1569            * @param structureKey the unique string identifying the structure
1570            * @param nameMap the structure's new locales and localized names
1571            * @param descriptionMap the structure's new locales and localized
1572            description
1573            * @param definition the structure's new XML schema definition
1574            * @param serviceContext the service context to be applied. Can set the
1575            structure's modification date.
1576            * @return the updated structure
1577            * @throws PortalException if a matching structure could not be found,
1578            if the XSD was not well-formed, or if a portal exception
1579            occurred
1580            * @deprecated As of 7.0.0, replaced by {@link #updateStructure(long, long,
1581            long, String, Map, Map, DDMForm, ServiceContext)}
1582            */
1583            @Deprecated
1584            @Override
1585            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1586                    long groupId, long parentStructureId, long classNameId,
1587                    java.lang.String structureKey,
1588                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1589                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1590                    java.lang.String definition,
1591                    com.liferay.portal.service.ServiceContext serviceContext)
1592                    throws com.liferay.portal.kernel.exception.PortalException {
1593                    return _ddmStructureLocalService.updateStructure(groupId,
1594                            parentStructureId, classNameId, structureKey, nameMap,
1595                            descriptionMap, definition, serviceContext);
1596            }
1597    
1598            @Override
1599            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1600                    long structureId, long parentStructureId,
1601                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1602                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1603                    com.liferay.portlet.dynamicdatamapping.model.DDMForm ddmForm,
1604                    com.liferay.portal.service.ServiceContext serviceContext)
1605                    throws com.liferay.portal.kernel.exception.PortalException {
1606                    return _ddmStructureLocalService.updateStructure(structureId,
1607                            parentStructureId, nameMap, descriptionMap, ddmForm, serviceContext);
1608            }
1609    
1610            /**
1611            * Updates the structure matching the structure ID, replacing its old parent
1612            * structure, name map, description map, and XSD with new ones.
1613            *
1614            * @param structureId the primary key of the structure
1615            * @param parentStructureId the primary key of the new parent structure
1616            * @param nameMap the structure's new locales and localized names
1617            * @param descriptionMap the structure's new locales and localized
1618            descriptions
1619            * @param definition the structure's new XML schema definition
1620            * @param serviceContext the service context to be applied. Can set the
1621            structure's modification date.
1622            * @return the updated structure
1623            * @throws PortalException if a matching structure could not be found,
1624            if the XSD was not well-formed, or if a portal exception
1625            occurred
1626            * @deprecated As of 7.0.0, replaced by {@link #updateStructure(long, long,
1627            Map, Map, DDMForm, ServiceContext)}
1628            */
1629            @Deprecated
1630            @Override
1631            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1632                    long structureId, long parentStructureId,
1633                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1634                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1635                    java.lang.String definition,
1636                    com.liferay.portal.service.ServiceContext serviceContext)
1637                    throws com.liferay.portal.kernel.exception.PortalException {
1638                    return _ddmStructureLocalService.updateStructure(structureId,
1639                            parentStructureId, nameMap, descriptionMap, definition,
1640                            serviceContext);
1641            }
1642    
1643            /**
1644            * Updates the structure matching the structure ID, replacing its XSD with a
1645            * new one.
1646            *
1647            * @param structureId the primary key of the structure
1648            * @param definition the structure's new XML schema definition
1649            * @param serviceContext the service context to be applied. Can set the
1650            structure's modification date.
1651            * @return the updated structure
1652            * @throws PortalException if a matching structure could not be found,
1653            if the XSD was not well-formed, or if a portal exception
1654            occurred
1655            * @deprecated As of 7.0.0, replaced by {@link #updateDDMForm(long, String,
1656            ServiceContext)}
1657            */
1658            @Deprecated
1659            @Override
1660            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateXSD(
1661                    long structureId, java.lang.String definition,
1662                    com.liferay.portal.service.ServiceContext serviceContext)
1663                    throws com.liferay.portal.kernel.exception.PortalException {
1664                    return _ddmStructureLocalService.updateXSD(structureId, definition,
1665                            serviceContext);
1666            }
1667    
1668            /**
1669             * @deprecated As of 6.1.0, replaced by {@link #getWrappedService}
1670             */
1671            @Deprecated
1672            public DDMStructureLocalService getWrappedDDMStructureLocalService() {
1673                    return _ddmStructureLocalService;
1674            }
1675    
1676            /**
1677             * @deprecated As of 6.1.0, replaced by {@link #setWrappedService}
1678             */
1679            @Deprecated
1680            public void setWrappedDDMStructureLocalService(
1681                    DDMStructureLocalService ddmStructureLocalService) {
1682                    _ddmStructureLocalService = ddmStructureLocalService;
1683            }
1684    
1685            @Override
1686            public DDMStructureLocalService getWrappedService() {
1687                    return _ddmStructureLocalService;
1688            }
1689    
1690            @Override
1691            public void setWrappedService(
1692                    DDMStructureLocalService ddmStructureLocalService) {
1693                    _ddmStructureLocalService = ddmStructureLocalService;
1694            }
1695    
1696            private DDMStructureLocalService _ddmStructureLocalService;
1697    }