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