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