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