001    /**
002     * Copyright (c) 2000-2012 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     * <p>
021     * This class is a wrapper for {@link DDMStructureLocalService}.
022     * </p>
023     *
024     * @author    Brian Wing Shun Chan
025     * @see       DDMStructureLocalService
026     * @generated
027     */
028    public class DDMStructureLocalServiceWrapper implements DDMStructureLocalService,
029            ServiceWrapper<DDMStructureLocalService> {
030            public DDMStructureLocalServiceWrapper(
031                    DDMStructureLocalService ddmStructureLocalService) {
032                    _ddmStructureLocalService = ddmStructureLocalService;
033            }
034    
035            /**
036            * Adds the d d m structure to the database. Also notifies the appropriate model listeners.
037            *
038            * @param ddmStructure the d d m structure
039            * @return the d d m structure that was added
040            * @throws SystemException if a system exception occurred
041            */
042            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addDDMStructure(
043                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure)
044                    throws com.liferay.portal.kernel.exception.SystemException {
045                    return _ddmStructureLocalService.addDDMStructure(ddmStructure);
046            }
047    
048            /**
049            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
050            *
051            * @param structureId the primary key for the new d d m structure
052            * @return the new d d m structure
053            */
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            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure(
068                    long structureId)
069                    throws com.liferay.portal.kernel.exception.PortalException,
070                            com.liferay.portal.kernel.exception.SystemException {
071                    return _ddmStructureLocalService.deleteDDMStructure(structureId);
072            }
073    
074            /**
075            * Deletes the d d m structure from the database. Also notifies the appropriate model listeners.
076            *
077            * @param ddmStructure the d d m structure
078            * @return the d d m structure that was removed
079            * @throws SystemException if a system exception occurred
080            */
081            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure deleteDDMStructure(
082                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure)
083                    throws com.liferay.portal.kernel.exception.SystemException {
084                    return _ddmStructureLocalService.deleteDDMStructure(ddmStructure);
085            }
086    
087            public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() {
088                    return _ddmStructureLocalService.dynamicQuery();
089            }
090    
091            /**
092            * Performs a dynamic query on the database and returns the matching rows.
093            *
094            * @param dynamicQuery the dynamic query
095            * @return the matching rows
096            * @throws SystemException if a system exception occurred
097            */
098            @SuppressWarnings("rawtypes")
099            public java.util.List dynamicQuery(
100                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
101                    throws com.liferay.portal.kernel.exception.SystemException {
102                    return _ddmStructureLocalService.dynamicQuery(dynamicQuery);
103            }
104    
105            /**
106            * Performs a dynamic query on the database and returns a range of the matching rows.
107            *
108            * <p>
109            * 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.
110            * </p>
111            *
112            * @param dynamicQuery the dynamic query
113            * @param start the lower bound of the range of model instances
114            * @param end the upper bound of the range of model instances (not inclusive)
115            * @return the range of matching rows
116            * @throws SystemException if a system exception occurred
117            */
118            @SuppressWarnings("rawtypes")
119            public java.util.List dynamicQuery(
120                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
121                    int end) throws com.liferay.portal.kernel.exception.SystemException {
122                    return _ddmStructureLocalService.dynamicQuery(dynamicQuery, start, end);
123            }
124    
125            /**
126            * Performs a dynamic query on the database and returns an ordered range of the matching rows.
127            *
128            * <p>
129            * 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.
130            * </p>
131            *
132            * @param dynamicQuery the dynamic query
133            * @param start the lower bound of the range of model instances
134            * @param end the upper bound of the range of model instances (not inclusive)
135            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
136            * @return the ordered range of matching rows
137            * @throws SystemException if a system exception occurred
138            */
139            @SuppressWarnings("rawtypes")
140            public java.util.List dynamicQuery(
141                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start,
142                    int end,
143                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
144                    throws com.liferay.portal.kernel.exception.SystemException {
145                    return _ddmStructureLocalService.dynamicQuery(dynamicQuery, start, end,
146                            orderByComparator);
147            }
148    
149            /**
150            * Returns the number of rows that match the dynamic query.
151            *
152            * @param dynamicQuery the dynamic query
153            * @return the number of rows that match the dynamic query
154            * @throws SystemException if a system exception occurred
155            */
156            public long dynamicQueryCount(
157                    com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery)
158                    throws com.liferay.portal.kernel.exception.SystemException {
159                    return _ddmStructureLocalService.dynamicQueryCount(dynamicQuery);
160            }
161    
162            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchDDMStructure(
163                    long structureId)
164                    throws com.liferay.portal.kernel.exception.SystemException {
165                    return _ddmStructureLocalService.fetchDDMStructure(structureId);
166            }
167    
168            /**
169            * Returns the d d m structure with the primary key.
170            *
171            * @param structureId the primary key of the d d m structure
172            * @return the d d m structure
173            * @throws PortalException if a d d m structure with the primary key could not be found
174            * @throws SystemException if a system exception occurred
175            */
176            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructure(
177                    long structureId)
178                    throws com.liferay.portal.kernel.exception.PortalException,
179                            com.liferay.portal.kernel.exception.SystemException {
180                    return _ddmStructureLocalService.getDDMStructure(structureId);
181            }
182    
183            public com.liferay.portal.model.PersistedModel getPersistedModel(
184                    java.io.Serializable primaryKeyObj)
185                    throws com.liferay.portal.kernel.exception.PortalException,
186                            com.liferay.portal.kernel.exception.SystemException {
187                    return _ddmStructureLocalService.getPersistedModel(primaryKeyObj);
188            }
189    
190            /**
191            * Returns the d d m structure with the UUID in the group.
192            *
193            * @param uuid the UUID of d d m structure
194            * @param groupId the group id of the d d m structure
195            * @return the d d m structure
196            * @throws PortalException if a d d m structure with the UUID in the group could not be found
197            * @throws SystemException if a system exception occurred
198            */
199            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getDDMStructureByUuidAndGroupId(
200                    java.lang.String uuid, long groupId)
201                    throws com.liferay.portal.kernel.exception.PortalException,
202                            com.liferay.portal.kernel.exception.SystemException {
203                    return _ddmStructureLocalService.getDDMStructureByUuidAndGroupId(uuid,
204                            groupId);
205            }
206    
207            /**
208            * Returns a range of all the d d m structures.
209            *
210            * <p>
211            * 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.
212            * </p>
213            *
214            * @param start the lower bound of the range of d d m structures
215            * @param end the upper bound of the range of d d m structures (not inclusive)
216            * @return the range of d d m structures
217            * @throws SystemException if a system exception occurred
218            */
219            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDDMStructures(
220                    int start, int end)
221                    throws com.liferay.portal.kernel.exception.SystemException {
222                    return _ddmStructureLocalService.getDDMStructures(start, end);
223            }
224    
225            /**
226            * Returns the number of d d m structures.
227            *
228            * @return the number of d d m structures
229            * @throws SystemException if a system exception occurred
230            */
231            public int getDDMStructuresCount()
232                    throws com.liferay.portal.kernel.exception.SystemException {
233                    return _ddmStructureLocalService.getDDMStructuresCount();
234            }
235    
236            /**
237            * Updates the d d m structure in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
238            *
239            * @param ddmStructure the d d m structure
240            * @return the d d m structure that was updated
241            * @throws SystemException if a system exception occurred
242            */
243            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateDDMStructure(
244                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure)
245                    throws com.liferay.portal.kernel.exception.SystemException {
246                    return _ddmStructureLocalService.updateDDMStructure(ddmStructure);
247            }
248    
249            /**
250            * Returns the Spring bean ID for this bean.
251            *
252            * @return the Spring bean ID for this bean
253            */
254            public java.lang.String getBeanIdentifier() {
255                    return _ddmStructureLocalService.getBeanIdentifier();
256            }
257    
258            /**
259            * Sets the Spring bean ID for this bean.
260            *
261            * @param beanIdentifier the Spring bean ID for this bean
262            */
263            public void setBeanIdentifier(java.lang.String beanIdentifier) {
264                    _ddmStructureLocalService.setBeanIdentifier(beanIdentifier);
265            }
266    
267            /**
268            * Adds a structure referencing its parent structure.
269            *
270            * @param userId the primary key of the structure's creator/owner
271            * @param groupId the primary key of the group
272            * @param parentStructureId the primary key of the parent structure
273            (optionally {@link
274            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants#DEFAULT_PARENT_STRUCTURE_ID})
275            * @param classNameId the primary key of the class name for the structure's
276            related model
277            * @param structureKey the unique string identifying the structure
278            (optionally <code>null</code>)
279            * @param nameMap the structure's locales and localized names
280            * @param descriptionMap the structure's locales and localized descriptions
281            * @param xsd the structure's XML schema definition
282            * @param storageType the structure's storage type. It can be "xml" or
283            "expando". For more information, see {@link
284            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
285            * @param type the structure's type. For more information, see {@link
286            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
287            * @param serviceContext the structure's service context. Can set the UUID,
288            creation date, modification date, guest permissions, and group
289            permissions for the structure.
290            * @return the structure
291            * @throws PortalException if a user with the primary key could not be
292            found, if the XSD was not well-formed, or if a portal exception
293            occurred
294            * @throws SystemException if a system exception occurred
295            */
296            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
297                    long userId, long groupId, long parentStructureId, long classNameId,
298                    java.lang.String structureKey,
299                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
300                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
301                    java.lang.String xsd, java.lang.String storageType, int type,
302                    com.liferay.portal.service.ServiceContext serviceContext)
303                    throws com.liferay.portal.kernel.exception.PortalException,
304                            com.liferay.portal.kernel.exception.SystemException {
305                    return _ddmStructureLocalService.addStructure(userId, groupId,
306                            parentStructureId, classNameId, structureKey, nameMap,
307                            descriptionMap, xsd, storageType, type, serviceContext);
308            }
309    
310            /**
311            * Adds a structure referencing a default parent structure, using the portal
312            * property <code>dynamic.data.lists.storage.type</code> storage type and
313            * default structure type.
314            *
315            * @param userId the primary key of the structure's creator/owner
316            * @param groupId the primary key of the group
317            * @param classNameId the primary key of the class name for the structure's
318            related model
319            * @param nameMap the structure's locales and localized names
320            * @param descriptionMap the structure's locales and localized descriptions
321            * @param xsd the structure's XML schema definition
322            * @param serviceContext the structure's service context. Can set the UUID,
323            creation date, modification date, guest permissions, and group
324            permissions for the structure.
325            * @return the structure
326            * @throws PortalException if a user with the primary key could not be
327            found, if the XSD was not well-formed, or if a portal exception
328            occurred
329            * @throws SystemException if a system exception occurred
330            */
331            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
332                    long userId, long groupId, long classNameId,
333                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
334                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
335                    java.lang.String xsd,
336                    com.liferay.portal.service.ServiceContext serviceContext)
337                    throws com.liferay.portal.kernel.exception.PortalException,
338                            com.liferay.portal.kernel.exception.SystemException {
339                    return _ddmStructureLocalService.addStructure(userId, groupId,
340                            classNameId, nameMap, descriptionMap, xsd, serviceContext);
341            }
342    
343            /**
344            * Adds a structure referencing a default parent structure if the parent
345            * structure is not found.
346            *
347            * @param userId the primary key of the structure's creator/owner
348            * @param groupId the primary key of the group
349            * @param parentStructureKey the unique string identifying the parent
350            structure (optionally <code>null</code>)
351            * @param classNameId the primary key of the class name for the structure's
352            related model
353            * @param structureKey the unique string identifying the structure
354            (optionally <code>null</code>)
355            * @param nameMap the structure's locales and localized names
356            * @param descriptionMap the structure's locales and localized descriptions
357            * @param xsd the structure's XML schema definition
358            * @param storageType the structure's storage type. It can be "xml" or
359            "expando". For more information, see {@link
360            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
361            * @param type the structure's type. For more information, see {@link
362            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
363            * @param serviceContext the structure's service context. Can set the UUID,
364            creation date, modification date, guest permissions and group
365            permissions for the structure.
366            * @return the structure
367            * @throws PortalException if a user with the primary key could not be
368            found, if the XSD was not well-formed, or if a portal exception
369            occurred
370            * @throws SystemException if a system exception occurred
371            */
372            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure addStructure(
373                    long userId, long groupId, java.lang.String parentStructureKey,
374                    long classNameId, java.lang.String structureKey,
375                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
376                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
377                    java.lang.String xsd, java.lang.String storageType, int type,
378                    com.liferay.portal.service.ServiceContext serviceContext)
379                    throws com.liferay.portal.kernel.exception.PortalException,
380                            com.liferay.portal.kernel.exception.SystemException {
381                    return _ddmStructureLocalService.addStructure(userId, groupId,
382                            parentStructureKey, classNameId, structureKey, nameMap,
383                            descriptionMap, xsd, storageType, type, serviceContext);
384            }
385    
386            /**
387            * Adds the resources to the structure.
388            *
389            * @param structure the structure to add resources to
390            * @param addGroupPermissions whether to add group permissions
391            * @param addGuestPermissions whether to add guest permissions
392            * @throws PortalException if a portal exception occurred
393            * @throws SystemException if a system exception occurred
394            */
395            public void addStructureResources(
396                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure,
397                    boolean addGroupPermissions, boolean addGuestPermissions)
398                    throws com.liferay.portal.kernel.exception.PortalException,
399                            com.liferay.portal.kernel.exception.SystemException {
400                    _ddmStructureLocalService.addStructureResources(structure,
401                            addGroupPermissions, addGuestPermissions);
402            }
403    
404            /**
405            * Adds the model resources with the permissions to the structure.
406            *
407            * @param structure the structure to add resources to
408            * @param groupPermissions the group permissions to be added
409            * @param guestPermissions the guest permissions to be added
410            * @throws PortalException if a portal exception occurred
411            * @throws SystemException if a system exception occurred
412            */
413            public void addStructureResources(
414                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure,
415                    java.lang.String[] groupPermissions, java.lang.String[] guestPermissions)
416                    throws com.liferay.portal.kernel.exception.PortalException,
417                            com.liferay.portal.kernel.exception.SystemException {
418                    _ddmStructureLocalService.addStructureResources(structure,
419                            groupPermissions, guestPermissions);
420            }
421    
422            /**
423            * Copies a structure, creating a new structure with all the values
424            * extracted from the original one. The new structure supports a new name
425            * and description.
426            *
427            * @param userId the primary key of the structure's creator/owner
428            * @param structureId the primary key of the structure to be copied
429            * @param nameMap the new structure's locales and localized names
430            * @param descriptionMap the new structure's locales and localized
431            descriptions
432            * @param serviceContext the service context to be applied. Can set the
433            UUID, creation date, modification date, guest permissions, and
434            group permissions for the structure.
435            * @return the new structure
436            * @throws PortalException if a portal exception occurred
437            * @throws SystemException if a system exception occurred
438            */
439            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
440                    long userId, long structureId,
441                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
442                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
443                    com.liferay.portal.service.ServiceContext serviceContext)
444                    throws com.liferay.portal.kernel.exception.PortalException,
445                            com.liferay.portal.kernel.exception.SystemException {
446                    return _ddmStructureLocalService.copyStructure(userId, structureId,
447                            nameMap, descriptionMap, serviceContext);
448            }
449    
450            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure copyStructure(
451                    long userId, long structureId,
452                    com.liferay.portal.service.ServiceContext serviceContext)
453                    throws com.liferay.portal.kernel.exception.PortalException,
454                            com.liferay.portal.kernel.exception.SystemException {
455                    return _ddmStructureLocalService.copyStructure(userId, structureId,
456                            serviceContext);
457            }
458    
459            /**
460            * Deletes the structure and its resources.
461            *
462            * <p>
463            * Before deleting the structure, this method verifies whether the structure
464            * is required by another entity. If it is needed, an exception is thrown.
465            * </p>
466            *
467            * @param structure the structure to be deleted
468            * @throws PortalException if a portal exception occurred
469            * @throws SystemException if a system exception occurred
470            */
471            public void deleteStructure(
472                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure structure)
473                    throws com.liferay.portal.kernel.exception.PortalException,
474                            com.liferay.portal.kernel.exception.SystemException {
475                    _ddmStructureLocalService.deleteStructure(structure);
476            }
477    
478            /**
479            * Deletes the structure and its resources.
480            *
481            * <p>
482            * Before deleting the structure, the system verifies whether the structure
483            * is required by another entity. If it is needed, an exception is thrown.
484            * </p>
485            *
486            * @param structureId the primary key of the structure to be deleted
487            * @throws PortalException if a portal exception occurred
488            * @throws SystemException if a system exception occurred
489            */
490            public void deleteStructure(long structureId)
491                    throws com.liferay.portal.kernel.exception.PortalException,
492                            com.liferay.portal.kernel.exception.SystemException {
493                    _ddmStructureLocalService.deleteStructure(structureId);
494            }
495    
496            /**
497            * Deletes the matching structure and its resources.
498            *
499            * <p>
500            * Before deleting the structure, the system verifies whether the structure
501            * is required by another entity. If it is needed, an exception is thrown.
502            * </p>
503            *
504            * @param groupId the primary key of the group
505            * @param classNameId the primary key of the class name for the structure's
506            related model
507            * @param structureKey the unique string identifying the structure
508            * @throws PortalException if a portal exception occurred
509            * @throws SystemException if a system exception occurred
510            */
511            public void deleteStructure(long groupId, long classNameId,
512                    java.lang.String structureKey)
513                    throws com.liferay.portal.kernel.exception.PortalException,
514                            com.liferay.portal.kernel.exception.SystemException {
515                    _ddmStructureLocalService.deleteStructure(groupId, classNameId,
516                            structureKey);
517            }
518    
519            /**
520            * Deletes all the structures of the group.
521            *
522            * <p>
523            * Before deleting the structures, the system verifies whether each
524            * structure is required by another entity. If any of the structures are
525            * needed, an exception is thrown.
526            * </p>
527            *
528            * @param groupId the primary key of the group
529            * @throws PortalException if a portal exception occurred
530            * @throws SystemException if a system exception occurred
531            */
532            public void deleteStructures(long groupId)
533                    throws com.liferay.portal.kernel.exception.PortalException,
534                            com.liferay.portal.kernel.exception.SystemException {
535                    _ddmStructureLocalService.deleteStructures(groupId);
536            }
537    
538            /**
539            * Returns the structure with the ID.
540            *
541            * @param structureId the primary key of the structure
542            * @return the structure with the structure ID, or <code>null</code> if a
543            matching structure could not be found
544            * @throws SystemException if a system exception occurred
545            */
546            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
547                    long structureId)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return _ddmStructureLocalService.fetchStructure(structureId);
550            }
551    
552            /**
553            * Returns the structure matching the class name ID, structure key, and
554            * group.
555            *
556            * @param groupId the primary key of the group
557            * @param classNameId the primary key of the class name for the structure's
558            related model
559            * @param structureKey the unique string identifying the structure
560            * @return the matching structure, or <code>null</code> if a matching
561            structure could not be found
562            * @throws SystemException if a system exception occurred
563            */
564            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
565                    long groupId, long classNameId, java.lang.String structureKey)
566                    throws com.liferay.portal.kernel.exception.SystemException {
567                    return _ddmStructureLocalService.fetchStructure(groupId, classNameId,
568                            structureKey);
569            }
570    
571            /**
572            * Returns the structure matching the class name ID, structure key, and
573            * group, optionally in the global scope.
574            *
575            * <p>
576            * This method first searches in the group. If the structure is still not
577            * found and <code>includeGlobalStructures</code> is set to
578            * <code>true</code>, this method searches the global group.
579            * </p>
580            *
581            * @param groupId the primary key of the group
582            * @param classNameId the primary key of the class name for the structure's
583            related model
584            * @param structureKey the unique string identifying the structure
585            * @param includeGlobalStructures whether to include the global scope in
586            the search
587            * @return the matching structure, or <code>null</code> if a matching
588            structure could not be found
589            * @throws PortalException if a portal exception occurred
590            * @throws SystemException if a system exception occurred
591            */
592            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
593                    long groupId, long classNameId, java.lang.String structureKey,
594                    boolean includeGlobalStructures)
595                    throws com.liferay.portal.kernel.exception.PortalException,
596                            com.liferay.portal.kernel.exception.SystemException {
597                    return _ddmStructureLocalService.fetchStructure(groupId, classNameId,
598                            structureKey, includeGlobalStructures);
599            }
600    
601            /**
602            * Returns the structure matching the UUID and group.
603            *
604            * @param uuid the structure's UUID
605            * @param groupId the primary key of the structure's group
606            * @return the matching structure, or <code>null</code> if a matching
607            structure could not be found
608            * @throws SystemException if a system exception occurred
609            */
610            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchStructure(
611                    java.lang.String uuid, long groupId)
612                    throws com.liferay.portal.kernel.exception.SystemException {
613                    return _ddmStructureLocalService.fetchStructure(uuid, groupId);
614            }
615    
616            /**
617            * @deprecated {@link #getClassStructures(long, long)}
618            */
619            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
620                    long classNameId)
621                    throws com.liferay.portal.kernel.exception.SystemException {
622                    return _ddmStructureLocalService.getClassStructures(classNameId);
623            }
624    
625            /**
626            * @deprecated {@link #getClassStructures(long, long, int, int)}
627            */
628            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
629                    long classNameId, int start, int end)
630                    throws com.liferay.portal.kernel.exception.SystemException {
631                    return _ddmStructureLocalService.getClassStructures(classNameId, start,
632                            end);
633            }
634    
635            /**
636            * Returns all the structures matching the class name ID.
637            *
638            * @param companyId the primary key of the structure's company
639            * @param classNameId the primary key of the class name for the structure's
640            related model
641            * @return the structures matching the class name ID
642            * @throws SystemException if a system exception occurred
643            */
644            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
645                    long companyId, long classNameId)
646                    throws com.liferay.portal.kernel.exception.SystemException {
647                    return _ddmStructureLocalService.getClassStructures(companyId,
648                            classNameId);
649            }
650    
651            /**
652            * Returns a range of all the structures matching the class name ID.
653            *
654            * <p>
655            * Useful when paginating results. Returns a maximum of <code>end -
656            * start</code> instances. <code>start</code> and <code>end</code> are not
657            * primary keys, they are indexes in the result set. Thus, <code>0</code>
658            * refers to the first result in the set. Setting both <code>start</code>
659            * and <code>end</code> to {@link
660            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
661            * result set.
662            * </p>
663            *
664            * @param companyId the primary key of the structure's company
665            * @param classNameId the primary key of the class name for the structure's
666            related model
667            * @param start the lower bound of the range of structures to return
668            * @param end the upper bound of the range of structures to return (not
669            inclusive)
670            * @return the range of matching structures
671            * @throws SystemException if a system exception occurred
672            */
673            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
674                    long companyId, long classNameId, int start, int end)
675                    throws com.liferay.portal.kernel.exception.SystemException {
676                    return _ddmStructureLocalService.getClassStructures(companyId,
677                            classNameId, start, end);
678            }
679    
680            /**
681            * Returns all the structures matching the class name ID ordered by the
682            * comparator.
683            *
684            * @param companyId the primary key of the structure's company
685            * @param classNameId the primary key of the class name for the structure's
686            related model
687            * @param orderByComparator the comparator to order the structures
688            (optionally <code>null</code>)
689            * @return the matching structures ordered by the comparator
690            * @throws SystemException if a system exception occurred
691            */
692            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
693                    long companyId, long classNameId,
694                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
695                    throws com.liferay.portal.kernel.exception.SystemException {
696                    return _ddmStructureLocalService.getClassStructures(companyId,
697                            classNameId, orderByComparator);
698            }
699    
700            /**
701            * @deprecated {@link #getClassStructures(long, long, OrderByComparator)}
702            */
703            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getClassStructures(
704                    long classNameId,
705                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
706                    throws com.liferay.portal.kernel.exception.SystemException {
707                    return _ddmStructureLocalService.getClassStructures(classNameId,
708                            orderByComparator);
709            }
710    
711            /**
712            * Returns all the structures for the document library file entry type.
713            *
714            * @param dlFileEntryTypeId the primary key of the document library file
715            entry type
716            * @return the structures for the document library file entry type
717            * @throws SystemException if a system exception occurred
718            */
719            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getDLFileEntryTypeStructures(
720                    long dlFileEntryTypeId)
721                    throws com.liferay.portal.kernel.exception.SystemException {
722                    return _ddmStructureLocalService.getDLFileEntryTypeStructures(dlFileEntryTypeId);
723            }
724    
725            /**
726            * Returns the structure with the ID.
727            *
728            * @param structureId the primary key of the structure
729            * @return the structure with the ID
730            * @throws PortalException if a structure with the ID could not be found
731            * @throws SystemException if a system exception occurred
732            */
733            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
734                    long structureId)
735                    throws com.liferay.portal.kernel.exception.PortalException,
736                            com.liferay.portal.kernel.exception.SystemException {
737                    return _ddmStructureLocalService.getStructure(structureId);
738            }
739    
740            /**
741            * Returns the structure matching the class name ID, structure key, and
742            * group.
743            *
744            * @param groupId the primary key of the structure's group
745            * @param classNameId the primary key of the class name for the structure's
746            related model
747            * @param structureKey the unique string identifying the structure
748            * @return the matching structure
749            * @throws PortalException if a matching structure could not be found
750            * @throws SystemException if a system exception occurred
751            */
752            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
753                    long groupId, long classNameId, java.lang.String structureKey)
754                    throws com.liferay.portal.kernel.exception.PortalException,
755                            com.liferay.portal.kernel.exception.SystemException {
756                    return _ddmStructureLocalService.getStructure(groupId, classNameId,
757                            structureKey);
758            }
759    
760            /**
761            * Returns the structure matching the class name ID, structure key, and
762            * group, optionally in the global scope.
763            *
764            * <p>
765            * This method first searches in the group. If the structure is still not
766            * found and <code>includeGlobalStructures</code> is set to
767            * <code>true</code>, this method searches the global group.
768            * </p>
769            *
770            * @param groupId the primary key of the structure's group
771            * @param classNameId the primary key of the class name for the structure's
772            related model
773            * @param structureKey the unique string identifying the structure
774            * @param includeGlobalStructures whether to include the global scope in
775            the search
776            * @return the matching structure
777            * @throws PortalException if a matching structure could not be found
778            * @throws SystemException if a system exception occurred
779            */
780            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure getStructure(
781                    long groupId, long classNameId, java.lang.String structureKey,
782                    boolean includeGlobalStructures)
783                    throws com.liferay.portal.kernel.exception.PortalException,
784                            com.liferay.portal.kernel.exception.SystemException {
785                    return _ddmStructureLocalService.getStructure(groupId, classNameId,
786                            structureKey, includeGlobalStructures);
787            }
788    
789            /**
790            * Returns all the structures matching the group, name, and description.
791            *
792            * @param groupId the primary key of the structure's group
793            * @param name the structure's name
794            * @param description the structure's description
795            * @return the matching structures
796            * @throws SystemException if a system exception occurred
797            */
798            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructure(
799                    long groupId, java.lang.String name, java.lang.String description)
800                    throws com.liferay.portal.kernel.exception.SystemException {
801                    return _ddmStructureLocalService.getStructure(groupId, name, description);
802            }
803    
804            /**
805            * @deprecated {@link #getStructures}
806            */
807            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries()
808                    throws com.liferay.portal.kernel.exception.SystemException {
809                    return _ddmStructureLocalService.getStructureEntries();
810            }
811    
812            /**
813            * @deprecated {@link #getStructures(long)}
814            */
815            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries(
816                    long groupId)
817                    throws com.liferay.portal.kernel.exception.SystemException {
818                    return _ddmStructureLocalService.getStructureEntries(groupId);
819            }
820    
821            /**
822            * @deprecated {@link #getStructures(long, int, int)}
823            */
824            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructureEntries(
825                    long groupId, int start, int end)
826                    throws com.liferay.portal.kernel.exception.SystemException {
827                    return _ddmStructureLocalService.getStructureEntries(groupId, start, end);
828            }
829    
830            /**
831            * Returns all the structures present in the system.
832            *
833            * @return the structures present in the system
834            * @throws SystemException if a system exception occurred
835            */
836            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures()
837                    throws com.liferay.portal.kernel.exception.SystemException {
838                    return _ddmStructureLocalService.getStructures();
839            }
840    
841            /**
842            * Returns all the structures present in the group.
843            *
844            * @param groupId the primary key of the group
845            * @return the structures present in the group
846            * @throws SystemException if a system exception occurred
847            */
848            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
849                    long groupId)
850                    throws com.liferay.portal.kernel.exception.SystemException {
851                    return _ddmStructureLocalService.getStructures(groupId);
852            }
853    
854            /**
855            * Returns a range of all the structures belonging to the group.
856            *
857            * <p>
858            * Useful when paginating results. Returns a maximum of <code>end -
859            * start</code> instances. <code>start</code> and <code>end</code> are not
860            * primary keys, they are indexes in the result set. Thus, <code>0</code>
861            * refers to the first result in the set. Setting both <code>start</code>
862            * and <code>end</code> to {@link
863            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
864            * result set.
865            * </p>
866            *
867            * @param groupId the primary key of the group
868            * @param start the lower bound of the range of structures to return
869            * @param end the upper bound of the range of structures to return (not
870            inclusive)
871            * @return the range of matching structures, or <code>null</code> if no
872            matches could be found
873            * @throws SystemException if a system exception occurred
874            */
875            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
876                    long groupId, int start, int end)
877                    throws com.liferay.portal.kernel.exception.SystemException {
878                    return _ddmStructureLocalService.getStructures(groupId, start, end);
879            }
880    
881            /**
882            * Returns all the structures matching class name ID and group.
883            *
884            * @param groupId the primary key of the group
885            * @param classNameId the primary key of the class name for the structure's
886            related model
887            * @return the matching structures
888            * @throws SystemException if a system exception occurred
889            */
890            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
891                    long groupId, long classNameId)
892                    throws com.liferay.portal.kernel.exception.SystemException {
893                    return _ddmStructureLocalService.getStructures(groupId, classNameId);
894            }
895    
896            /**
897            * Returns a range of all the structures that match the class name ID and
898            * group.
899            *
900            * <p>
901            * Useful when paginating results. Returns a maximum of <code>end -
902            * start</code> instances. <code>start</code> and <code>end</code> are not
903            * primary keys, they are indexes in the result set. Thus, <code>0</code>
904            * refers to the first result in the set. Setting both <code>start</code>
905            * and <code>end</code> to {@link
906            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
907            * result set.
908            * </p>
909            *
910            * @param groupId the primary key of the group
911            * @param classNameId the primary key of the class name for the structure's
912            related model
913            * @param start the lower bound of the range of structures to return
914            * @param end the upper bound of the range of structures to return (not
915            inclusive)
916            * @return the matching structures, or <code>null</code> if no matching
917            structures could be found
918            * @throws SystemException if a system exception occurred
919            */
920            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
921                    long groupId, long classNameId, int start, int end)
922                    throws com.liferay.portal.kernel.exception.SystemException {
923                    return _ddmStructureLocalService.getStructures(groupId, classNameId,
924                            start, end);
925            }
926    
927            /**
928            * Returns an ordered range of all the structures matching the class name ID
929            * and group.
930            *
931            * <p>
932            * Useful when paginating results. Returns a maximum of <code>end -
933            * start</code> instances. <code>start</code> and <code>end</code> are not
934            * primary keys, they are indexes in the result set. Thus, <code>0</code>
935            * refers to the first result in the set. Setting both <code>start</code>
936            * and <code>end</code> to {@link
937            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
938            * result set.
939            * </p>
940            *
941            * @param groupId the primary key of the group
942            * @param classNameId the primary key of the class name for the structure's
943            related model
944            * @param start the lower bound of the range of structures to return
945            * @param end the upper bound of the range of structures to return (not
946            inclusive)
947            * @param orderByComparator the comparator to order the structures
948            (optionally <code>null</code>)
949            * @return the range of matching structures ordered by the comparator
950            * @throws SystemException if a system exception occurred
951            */
952            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
953                    long groupId, long classNameId, int start, int end,
954                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
955                    throws com.liferay.portal.kernel.exception.SystemException {
956                    return _ddmStructureLocalService.getStructures(groupId, classNameId,
957                            start, end, orderByComparator);
958            }
959    
960            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
961                    long groupId, java.lang.String name, java.lang.String description)
962                    throws com.liferay.portal.kernel.exception.SystemException {
963                    return _ddmStructureLocalService.getStructures(groupId, name,
964                            description);
965            }
966    
967            /**
968            * Returns all the structures belonging to the groups.
969            *
970            * @param groupIds the primary keys of the groups
971            * @return the structures belonging to the groups
972            * @throws SystemException if a system exception occurred
973            */
974            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> getStructures(
975                    long[] groupIds)
976                    throws com.liferay.portal.kernel.exception.SystemException {
977                    return _ddmStructureLocalService.getStructures(groupIds);
978            }
979    
980            /**
981            * Returns the number of structures belonging to the group.
982            *
983            * @param groupId the primary key of the group
984            * @return the number of structures belonging to the group
985            * @throws SystemException if a system exception occurred
986            */
987            public int getStructuresCount(long groupId)
988                    throws com.liferay.portal.kernel.exception.SystemException {
989                    return _ddmStructureLocalService.getStructuresCount(groupId);
990            }
991    
992            /**
993            * Returns the number of structures matching the class name ID and group.
994            *
995            * @param groupId the primary key of the group
996            * @param classNameId the primary key of the class name for the structure's
997            related model
998            * @return the number of matching structures
999            * @throws SystemException if a system exception occurred
1000            */
1001            public int getStructuresCount(long groupId, long classNameId)
1002                    throws com.liferay.portal.kernel.exception.SystemException {
1003                    return _ddmStructureLocalService.getStructuresCount(groupId, classNameId);
1004            }
1005    
1006            /**
1007            * Returns an ordered range of all the structures matching the groups and
1008            * class name IDs, and matching the keywords in the structure names and
1009            * descriptions.
1010            *
1011            * <p>
1012            * Useful when paginating results. Returns a maximum of <code>end -
1013            * start</code> instances. <code>start</code> and <code>end</code> are not
1014            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1015            * refers to the first result in the set. Setting both <code>start</code>
1016            * and <code>end</code> to {@link
1017            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1018            * result set.
1019            * </p>
1020            *
1021            * @param companyId the primary key of the structure's company
1022            * @param groupIds the primary keys of the groups
1023            * @param classNameIds the primary keys of the class names of the models
1024            the structures are related to
1025            * @param keywords the keywords (space separated), which may occur in the
1026            structure's name or description (optionally <code>null</code>)
1027            * @param start the lower bound of the range of structures to return
1028            * @param end the upper bound of the range of structures to return (not
1029            inclusive)
1030            * @param orderByComparator the comparator to order the structures
1031            (optionally <code>null</code>)
1032            * @return the range of matching structures ordered by the comparator
1033            * @throws SystemException if a system exception occurred
1034            */
1035            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
1036                    long companyId, long[] groupIds, long[] classNameIds,
1037                    java.lang.String keywords, int start, int end,
1038                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1039                    throws com.liferay.portal.kernel.exception.SystemException {
1040                    return _ddmStructureLocalService.search(companyId, groupIds,
1041                            classNameIds, keywords, start, end, orderByComparator);
1042            }
1043    
1044            /**
1045            * Returns an ordered range of all the structures matching the groups, class
1046            * name IDs, name keyword, description keyword, storage type, and type.
1047            *
1048            * <p>
1049            * Useful when paginating results. Returns a maximum of <code>end -
1050            * start</code> instances. <code>start</code> and <code>end</code> are not
1051            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1052            * refers to the first result in the set. Setting both <code>start</code>
1053            * and <code>end</code> to {@link
1054            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1055            * result set.
1056            * </p>
1057            *
1058            * @param companyId the primary key of the structure's company
1059            * @param groupIds the primary keys of the groups
1060            * @param classNameIds the primary keys of the class names of the models
1061            the structures are related to
1062            * @param name the name keywords
1063            * @param description the description keywords
1064            * @param storageType the structure's storage type. It can be "xml" or
1065            "expando". For more information, see {@link
1066            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
1067            * @param type the structure's type. For more information, see {@link
1068            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
1069            * @param andOperator whether every field must match its keywords, or just
1070            one field
1071            * @param start the lower bound of the range of structures to return
1072            * @param end the upper bound of the range of structures to return (not
1073            inclusive)
1074            * @param orderByComparator the comparator to order the structures
1075            (optionally <code>null</code>)
1076            * @return the range of matching structures ordered by the comparator
1077            * @throws SystemException if a system exception occurred
1078            */
1079            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> search(
1080                    long companyId, long[] groupIds, long[] classNameIds,
1081                    java.lang.String name, java.lang.String description,
1082                    java.lang.String storageType, int type, boolean andOperator, int start,
1083                    int end,
1084                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1085                    throws com.liferay.portal.kernel.exception.SystemException {
1086                    return _ddmStructureLocalService.search(companyId, groupIds,
1087                            classNameIds, name, description, storageType, type, andOperator,
1088                            start, end, orderByComparator);
1089            }
1090    
1091            /**
1092            * Returns the number of structures matching the groups and class name IDs,
1093            * and matching the keywords in the structure names and descriptions.
1094            *
1095            * @param companyId the primary key of the structure's company
1096            * @param groupIds the primary keys of the groups
1097            * @param classNameIds the primary keys of the class names of the models
1098            the structures are related to
1099            * @param keywords the keywords (space separated), which may occur in the
1100            structure's name or description (optionally <code>null</code>)
1101            * @return the number of matching structures
1102            * @throws SystemException if a system exception occurred
1103            */
1104            public int searchCount(long companyId, long[] groupIds,
1105                    long[] classNameIds, java.lang.String keywords)
1106                    throws com.liferay.portal.kernel.exception.SystemException {
1107                    return _ddmStructureLocalService.searchCount(companyId, groupIds,
1108                            classNameIds, keywords);
1109            }
1110    
1111            /**
1112            * Returns the number of structures matching the groups, class name IDs,
1113            * name keyword, description keyword, storage type, and type
1114            *
1115            * @param companyId the primary key of the structure's company
1116            * @param groupIds the primary keys of the groups
1117            * @param classNameIds the primary keys of the class names of the models
1118            the structure's are related to
1119            * @param name the name keywords
1120            * @param description the description keywords
1121            * @param storageType the structure's storage type. It can be "xml" or
1122            "expando". For more information, see {@link
1123            com.liferay.portlet.dynamicdatamapping.storage.StorageType}.
1124            * @param type the structure's type. For more information, see {@link
1125            com.liferay.portlet.dynamicdatamapping.model.DDMStructureConstants}.
1126            * @param andOperator whether every field must match its keywords, or just
1127            one field
1128            * @return the number of matching structures
1129            * @throws SystemException if a system exception occurred
1130            */
1131            public int searchCount(long companyId, long[] groupIds,
1132                    long[] classNameIds, java.lang.String name,
1133                    java.lang.String description, java.lang.String storageType, int type,
1134                    boolean andOperator)
1135                    throws com.liferay.portal.kernel.exception.SystemException {
1136                    return _ddmStructureLocalService.searchCount(companyId, groupIds,
1137                            classNameIds, name, description, storageType, type, andOperator);
1138            }
1139    
1140            /**
1141            * Updates the structure matching the class name ID, structure key, and
1142            * group, replacing its old parent structure, name map, description map, and
1143            * XSD with new ones.
1144            *
1145            * @param groupId the primary key of the group
1146            * @param parentStructureId the primary key of the new parent structure
1147            * @param classNameId the primary key of the class name for the structure's
1148            related model
1149            * @param structureKey the unique string identifying the structure
1150            * @param nameMap the structure's new locales and localized names
1151            * @param descriptionMap the structure's new locales and localized
1152            description
1153            * @param xsd the structure's new XML schema definition
1154            * @param serviceContext the service context to be applied. Can set the
1155            structure's modification date.
1156            * @return the updated structure
1157            * @throws PortalException if a matching structure could not be found, if
1158            the XSD was not well-formed, or if a portal exception occurred
1159            * @throws SystemException if a system exception occurred
1160            */
1161            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1162                    long groupId, long parentStructureId, long classNameId,
1163                    java.lang.String structureKey,
1164                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1165                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1166                    java.lang.String xsd,
1167                    com.liferay.portal.service.ServiceContext serviceContext)
1168                    throws com.liferay.portal.kernel.exception.PortalException,
1169                            com.liferay.portal.kernel.exception.SystemException {
1170                    return _ddmStructureLocalService.updateStructure(groupId,
1171                            parentStructureId, classNameId, structureKey, nameMap,
1172                            descriptionMap, xsd, serviceContext);
1173            }
1174    
1175            /**
1176            * Updates the structure matching the structure ID, replacing its old parent
1177            * structure, name map, description map, and XSD with new ones.
1178            *
1179            * @param structureId the primary key of the structure
1180            * @param parentStructureId the primary key of the new parent structure
1181            * @param nameMap the structure's new locales and localized names
1182            * @param descriptionMap the structure's new locales and localized
1183            descriptions
1184            * @param xsd the structure's new XML schema definition
1185            * @param serviceContext the service context to be applied. Can set the
1186            structure's modification date.
1187            * @return the updated structure
1188            * @throws PortalException if a matching structure could not be found, if
1189            the XSD was not well-formed, or if a portal exception occurred
1190            * @throws SystemException if a system exception occurred
1191            */
1192            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateStructure(
1193                    long structureId, long parentStructureId,
1194                    java.util.Map<java.util.Locale, java.lang.String> nameMap,
1195                    java.util.Map<java.util.Locale, java.lang.String> descriptionMap,
1196                    java.lang.String xsd,
1197                    com.liferay.portal.service.ServiceContext serviceContext)
1198                    throws com.liferay.portal.kernel.exception.PortalException,
1199                            com.liferay.portal.kernel.exception.SystemException {
1200                    return _ddmStructureLocalService.updateStructure(structureId,
1201                            parentStructureId, nameMap, descriptionMap, xsd, serviceContext);
1202            }
1203    
1204            /**
1205            * Updates the structure matching the structure ID, replacing its XSD with a
1206            * new one.
1207            *
1208            * @param structureId the primary key of the structure
1209            * @param xsd the structure's new XML schema definition
1210            * @param serviceContext the service context to be applied. Can set the
1211            structure's modification date.
1212            * @return the updated structure
1213            * @throws PortalException if a matching structure could not be found, if
1214            the XSD was not well-formed, or if a portal exception occurred
1215            * @throws SystemException if a system exception occurred
1216            */
1217            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateXSD(
1218                    long structureId, java.lang.String xsd,
1219                    com.liferay.portal.service.ServiceContext serviceContext)
1220                    throws com.liferay.portal.kernel.exception.PortalException,
1221                            com.liferay.portal.kernel.exception.SystemException {
1222                    return _ddmStructureLocalService.updateXSD(structureId, xsd,
1223                            serviceContext);
1224            }
1225    
1226            /**
1227            * Updates the structure matching the structure ID, replacing the metadata
1228            * entry of the named field.
1229            *
1230            * @param structureId the primary key of the structure
1231            * @param fieldName the name of the field whose metadata to update
1232            * @param metadataEntryName the metadata entry's name
1233            * @param metadataEntryValue the metadata entry's value
1234            * @param serviceContext the service context to be applied. Can set the
1235            structure's modification date.
1236            * @throws PortalException if a matching structure could not be found, if
1237            the XSD was not well-formed, or if a portal exception occurred
1238            * @throws SystemException if a system exception occurred
1239            */
1240            public void updateXSDFieldMetadata(long structureId,
1241                    java.lang.String fieldName, java.lang.String metadataEntryName,
1242                    java.lang.String metadataEntryValue,
1243                    com.liferay.portal.service.ServiceContext serviceContext)
1244                    throws com.liferay.portal.kernel.exception.PortalException,
1245                            com.liferay.portal.kernel.exception.SystemException {
1246                    _ddmStructureLocalService.updateXSDFieldMetadata(structureId,
1247                            fieldName, metadataEntryName, metadataEntryValue, serviceContext);
1248            }
1249    
1250            /**
1251             * @deprecated Renamed to {@link #getWrappedService}
1252             */
1253            public DDMStructureLocalService getWrappedDDMStructureLocalService() {
1254                    return _ddmStructureLocalService;
1255            }
1256    
1257            /**
1258             * @deprecated Renamed to {@link #setWrappedService}
1259             */
1260            public void setWrappedDDMStructureLocalService(
1261                    DDMStructureLocalService ddmStructureLocalService) {
1262                    _ddmStructureLocalService = ddmStructureLocalService;
1263            }
1264    
1265            public DDMStructureLocalService getWrappedService() {
1266                    return _ddmStructureLocalService;
1267            }
1268    
1269            public void setWrappedService(
1270                    DDMStructureLocalService ddmStructureLocalService) {
1271                    _ddmStructureLocalService = ddmStructureLocalService;
1272            }
1273    
1274            private DDMStructureLocalService _ddmStructureLocalService;
1275    }