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.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the d d m structure service. This utility wraps {@link DDMStructurePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see DDMStructurePersistence
037     * @see DDMStructurePersistenceImpl
038     * @generated
039     */
040    public class DDMStructureUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(DDMStructure ddmStructure) {
058                    getPersistence().clearCache(ddmStructure);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<DDMStructure> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<DDMStructure> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<DDMStructure> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static DDMStructure update(DDMStructure ddmStructure)
101                    throws SystemException {
102                    return getPersistence().update(ddmStructure);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static DDMStructure update(DDMStructure ddmStructure,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(ddmStructure, serviceContext);
111            }
112    
113            /**
114            * Returns all the d d m structures where uuid = &#63;.
115            *
116            * @param uuid the uuid
117            * @return the matching d d m structures
118            * @throws SystemException if a system exception occurred
119            */
120            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
121                    java.lang.String uuid)
122                    throws com.liferay.portal.kernel.exception.SystemException {
123                    return getPersistence().findByUuid(uuid);
124            }
125    
126            /**
127            * Returns a range of all the d d m structures where uuid = &#63;.
128            *
129            * <p>
130            * 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.
131            * </p>
132            *
133            * @param uuid the uuid
134            * @param start the lower bound of the range of d d m structures
135            * @param end the upper bound of the range of d d m structures (not inclusive)
136            * @return the range of matching d d m structures
137            * @throws SystemException if a system exception occurred
138            */
139            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
140                    java.lang.String uuid, int start, int end)
141                    throws com.liferay.portal.kernel.exception.SystemException {
142                    return getPersistence().findByUuid(uuid, start, end);
143            }
144    
145            /**
146            * Returns an ordered range of all the d d m structures where uuid = &#63;.
147            *
148            * <p>
149            * 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.
150            * </p>
151            *
152            * @param uuid the uuid
153            * @param start the lower bound of the range of d d m structures
154            * @param end the upper bound of the range of d d m structures (not inclusive)
155            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
156            * @return the ordered range of matching d d m structures
157            * @throws SystemException if a system exception occurred
158            */
159            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
160                    java.lang.String uuid, int start, int end,
161                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
164            }
165    
166            /**
167            * Returns the first d d m structure in the ordered set where uuid = &#63;.
168            *
169            * @param uuid the uuid
170            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
171            * @return the first matching d d m structure
172            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
173            * @throws SystemException if a system exception occurred
174            */
175            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_First(
176                    java.lang.String uuid,
177                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
178                    throws com.liferay.portal.kernel.exception.SystemException,
179                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
180                    return getPersistence().findByUuid_First(uuid, orderByComparator);
181            }
182    
183            /**
184            * Returns the first d d m structure in the ordered set where uuid = &#63;.
185            *
186            * @param uuid the uuid
187            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
188            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
189            * @throws SystemException if a system exception occurred
190            */
191            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_First(
192                    java.lang.String uuid,
193                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
194                    throws com.liferay.portal.kernel.exception.SystemException {
195                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
196            }
197    
198            /**
199            * Returns the last d d m structure in the ordered set where uuid = &#63;.
200            *
201            * @param uuid the uuid
202            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
203            * @return the last matching d d m structure
204            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
205            * @throws SystemException if a system exception occurred
206            */
207            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_Last(
208                    java.lang.String uuid,
209                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
210                    throws com.liferay.portal.kernel.exception.SystemException,
211                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
212                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
213            }
214    
215            /**
216            * Returns the last d d m structure in the ordered set where uuid = &#63;.
217            *
218            * @param uuid the uuid
219            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
220            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
221            * @throws SystemException if a system exception occurred
222            */
223            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_Last(
224                    java.lang.String uuid,
225                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
226                    throws com.liferay.portal.kernel.exception.SystemException {
227                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
228            }
229    
230            /**
231            * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = &#63;.
232            *
233            * @param structureId the primary key of the current d d m structure
234            * @param uuid the uuid
235            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
236            * @return the previous, current, and next d d m structure
237            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
238            * @throws SystemException if a system exception occurred
239            */
240            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_PrevAndNext(
241                    long structureId, java.lang.String uuid,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException,
244                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
245                    return getPersistence()
246                                       .findByUuid_PrevAndNext(structureId, uuid, orderByComparator);
247            }
248    
249            /**
250            * Removes all the d d m structures where uuid = &#63; from the database.
251            *
252            * @param uuid the uuid
253            * @throws SystemException if a system exception occurred
254            */
255            public static void removeByUuid(java.lang.String uuid)
256                    throws com.liferay.portal.kernel.exception.SystemException {
257                    getPersistence().removeByUuid(uuid);
258            }
259    
260            /**
261            * Returns the number of d d m structures where uuid = &#63;.
262            *
263            * @param uuid the uuid
264            * @return the number of matching d d m structures
265            * @throws SystemException if a system exception occurred
266            */
267            public static int countByUuid(java.lang.String uuid)
268                    throws com.liferay.portal.kernel.exception.SystemException {
269                    return getPersistence().countByUuid(uuid);
270            }
271    
272            /**
273            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found.
274            *
275            * @param uuid the uuid
276            * @param groupId the group ID
277            * @return the matching d d m structure
278            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUUID_G(
282                    java.lang.String uuid, long groupId)
283                    throws com.liferay.portal.kernel.exception.SystemException,
284                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
285                    return getPersistence().findByUUID_G(uuid, groupId);
286            }
287    
288            /**
289            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
290            *
291            * @param uuid the uuid
292            * @param groupId the group ID
293            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
294            * @throws SystemException if a system exception occurred
295            */
296            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G(
297                    java.lang.String uuid, long groupId)
298                    throws com.liferay.portal.kernel.exception.SystemException {
299                    return getPersistence().fetchByUUID_G(uuid, groupId);
300            }
301    
302            /**
303            * Returns the d d m structure where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
304            *
305            * @param uuid the uuid
306            * @param groupId the group ID
307            * @param retrieveFromCache whether to use the finder cache
308            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
309            * @throws SystemException if a system exception occurred
310            */
311            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G(
312                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
313                    throws com.liferay.portal.kernel.exception.SystemException {
314                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
315            }
316    
317            /**
318            * Removes the d d m structure where uuid = &#63; and groupId = &#63; from the database.
319            *
320            * @param uuid the uuid
321            * @param groupId the group ID
322            * @return the d d m structure that was removed
323            * @throws SystemException if a system exception occurred
324            */
325            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByUUID_G(
326                    java.lang.String uuid, long groupId)
327                    throws com.liferay.portal.kernel.exception.SystemException,
328                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
329                    return getPersistence().removeByUUID_G(uuid, groupId);
330            }
331    
332            /**
333            * Returns the number of d d m structures where uuid = &#63; and groupId = &#63;.
334            *
335            * @param uuid the uuid
336            * @param groupId the group ID
337            * @return the number of matching d d m structures
338            * @throws SystemException if a system exception occurred
339            */
340            public static int countByUUID_G(java.lang.String uuid, long groupId)
341                    throws com.liferay.portal.kernel.exception.SystemException {
342                    return getPersistence().countByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns all the d d m structures where uuid = &#63; and companyId = &#63;.
347            *
348            * @param uuid the uuid
349            * @param companyId the company ID
350            * @return the matching d d m structures
351            * @throws SystemException if a system exception occurred
352            */
353            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
354                    java.lang.String uuid, long companyId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().findByUuid_C(uuid, companyId);
357            }
358    
359            /**
360            * Returns a range of all the d d m structures where uuid = &#63; and companyId = &#63;.
361            *
362            * <p>
363            * 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.
364            * </p>
365            *
366            * @param uuid the uuid
367            * @param companyId the company ID
368            * @param start the lower bound of the range of d d m structures
369            * @param end the upper bound of the range of d d m structures (not inclusive)
370            * @return the range of matching d d m structures
371            * @throws SystemException if a system exception occurred
372            */
373            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
374                    java.lang.String uuid, long companyId, int start, int end)
375                    throws com.liferay.portal.kernel.exception.SystemException {
376                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
377            }
378    
379            /**
380            * Returns an ordered range of all the d d m structures where uuid = &#63; and companyId = &#63;.
381            *
382            * <p>
383            * 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.
384            * </p>
385            *
386            * @param uuid the uuid
387            * @param companyId the company ID
388            * @param start the lower bound of the range of d d m structures
389            * @param end the upper bound of the range of d d m structures (not inclusive)
390            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
391            * @return the ordered range of matching d d m structures
392            * @throws SystemException if a system exception occurred
393            */
394            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
395                    java.lang.String uuid, long companyId, int start, int end,
396                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
397                    throws com.liferay.portal.kernel.exception.SystemException {
398                    return getPersistence()
399                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
400            }
401    
402            /**
403            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
404            *
405            * @param uuid the uuid
406            * @param companyId the company ID
407            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
408            * @return the first matching d d m structure
409            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
410            * @throws SystemException if a system exception occurred
411            */
412            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_First(
413                    java.lang.String uuid, long companyId,
414                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
415                    throws com.liferay.portal.kernel.exception.SystemException,
416                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
417                    return getPersistence()
418                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
419            }
420    
421            /**
422            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
423            *
424            * @param uuid the uuid
425            * @param companyId the company ID
426            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
427            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
428            * @throws SystemException if a system exception occurred
429            */
430            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_First(
431                    java.lang.String uuid, long companyId,
432                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
433                    throws com.liferay.portal.kernel.exception.SystemException {
434                    return getPersistence()
435                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
436            }
437    
438            /**
439            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
440            *
441            * @param uuid the uuid
442            * @param companyId the company ID
443            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
444            * @return the last matching d d m structure
445            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
446            * @throws SystemException if a system exception occurred
447            */
448            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_Last(
449                    java.lang.String uuid, long companyId,
450                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
451                    throws com.liferay.portal.kernel.exception.SystemException,
452                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
453                    return getPersistence()
454                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
455            }
456    
457            /**
458            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
459            *
460            * @param uuid the uuid
461            * @param companyId the company ID
462            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
463            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_Last(
467                    java.lang.String uuid, long companyId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException {
470                    return getPersistence()
471                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
472            }
473    
474            /**
475            * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
476            *
477            * @param structureId the primary key of the current d d m structure
478            * @param uuid the uuid
479            * @param companyId the company ID
480            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
481            * @return the previous, current, and next d d m structure
482            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
483            * @throws SystemException if a system exception occurred
484            */
485            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_C_PrevAndNext(
486                    long structureId, java.lang.String uuid, long companyId,
487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
488                    throws com.liferay.portal.kernel.exception.SystemException,
489                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
490                    return getPersistence()
491                                       .findByUuid_C_PrevAndNext(structureId, uuid, companyId,
492                            orderByComparator);
493            }
494    
495            /**
496            * Removes all the d d m structures where uuid = &#63; and companyId = &#63; from the database.
497            *
498            * @param uuid the uuid
499            * @param companyId the company ID
500            * @throws SystemException if a system exception occurred
501            */
502            public static void removeByUuid_C(java.lang.String uuid, long companyId)
503                    throws com.liferay.portal.kernel.exception.SystemException {
504                    getPersistence().removeByUuid_C(uuid, companyId);
505            }
506    
507            /**
508            * Returns the number of d d m structures where uuid = &#63; and companyId = &#63;.
509            *
510            * @param uuid the uuid
511            * @param companyId the company ID
512            * @return the number of matching d d m structures
513            * @throws SystemException if a system exception occurred
514            */
515            public static int countByUuid_C(java.lang.String uuid, long companyId)
516                    throws com.liferay.portal.kernel.exception.SystemException {
517                    return getPersistence().countByUuid_C(uuid, companyId);
518            }
519    
520            /**
521            * Returns all the d d m structures where groupId = &#63;.
522            *
523            * @param groupId the group ID
524            * @return the matching d d m structures
525            * @throws SystemException if a system exception occurred
526            */
527            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
528                    long groupId)
529                    throws com.liferay.portal.kernel.exception.SystemException {
530                    return getPersistence().findByGroupId(groupId);
531            }
532    
533            /**
534            * Returns a range of all the d d m structures where groupId = &#63;.
535            *
536            * <p>
537            * 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.
538            * </p>
539            *
540            * @param groupId the group ID
541            * @param start the lower bound of the range of d d m structures
542            * @param end the upper bound of the range of d d m structures (not inclusive)
543            * @return the range of matching d d m structures
544            * @throws SystemException if a system exception occurred
545            */
546            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
547                    long groupId, int start, int end)
548                    throws com.liferay.portal.kernel.exception.SystemException {
549                    return getPersistence().findByGroupId(groupId, start, end);
550            }
551    
552            /**
553            * Returns an ordered range of all the d d m structures where groupId = &#63;.
554            *
555            * <p>
556            * 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.
557            * </p>
558            *
559            * @param groupId the group ID
560            * @param start the lower bound of the range of d d m structures
561            * @param end the upper bound of the range of d d m structures (not inclusive)
562            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
563            * @return the ordered range of matching d d m structures
564            * @throws SystemException if a system exception occurred
565            */
566            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
567                    long groupId, int start, int end,
568                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
569                    throws com.liferay.portal.kernel.exception.SystemException {
570                    return getPersistence()
571                                       .findByGroupId(groupId, start, end, orderByComparator);
572            }
573    
574            /**
575            * Returns the first d d m structure in the ordered set where groupId = &#63;.
576            *
577            * @param groupId the group ID
578            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
579            * @return the first matching d d m structure
580            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
581            * @throws SystemException if a system exception occurred
582            */
583            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_First(
584                    long groupId,
585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
586                    throws com.liferay.portal.kernel.exception.SystemException,
587                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
588                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
589            }
590    
591            /**
592            * Returns the first d d m structure in the ordered set where groupId = &#63;.
593            *
594            * @param groupId the group ID
595            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
596            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
597            * @throws SystemException if a system exception occurred
598            */
599            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_First(
600                    long groupId,
601                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
602                    throws com.liferay.portal.kernel.exception.SystemException {
603                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
604            }
605    
606            /**
607            * Returns the last d d m structure in the ordered set where groupId = &#63;.
608            *
609            * @param groupId the group ID
610            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
611            * @return the last matching d d m structure
612            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
613            * @throws SystemException if a system exception occurred
614            */
615            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_Last(
616                    long groupId,
617                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
618                    throws com.liferay.portal.kernel.exception.SystemException,
619                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
620                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
621            }
622    
623            /**
624            * Returns the last d d m structure in the ordered set where groupId = &#63;.
625            *
626            * @param groupId the group ID
627            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
628            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
629            * @throws SystemException if a system exception occurred
630            */
631            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_Last(
632                    long groupId,
633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
634                    throws com.liferay.portal.kernel.exception.SystemException {
635                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
636            }
637    
638            /**
639            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63;.
640            *
641            * @param structureId the primary key of the current d d m structure
642            * @param groupId the group ID
643            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
644            * @return the previous, current, and next d d m structure
645            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
646            * @throws SystemException if a system exception occurred
647            */
648            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByGroupId_PrevAndNext(
649                    long structureId, long groupId,
650                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
651                    throws com.liferay.portal.kernel.exception.SystemException,
652                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
653                    return getPersistence()
654                                       .findByGroupId_PrevAndNext(structureId, groupId,
655                            orderByComparator);
656            }
657    
658            /**
659            * Returns all the d d m structures that the user has permission to view where groupId = &#63;.
660            *
661            * @param groupId the group ID
662            * @return the matching d d m structures that the user has permission to view
663            * @throws SystemException if a system exception occurred
664            */
665            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
666                    long groupId)
667                    throws com.liferay.portal.kernel.exception.SystemException {
668                    return getPersistence().filterFindByGroupId(groupId);
669            }
670    
671            /**
672            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63;.
673            *
674            * <p>
675            * 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.
676            * </p>
677            *
678            * @param groupId the group ID
679            * @param start the lower bound of the range of d d m structures
680            * @param end the upper bound of the range of d d m structures (not inclusive)
681            * @return the range of matching d d m structures that the user has permission to view
682            * @throws SystemException if a system exception occurred
683            */
684            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
685                    long groupId, int start, int end)
686                    throws com.liferay.portal.kernel.exception.SystemException {
687                    return getPersistence().filterFindByGroupId(groupId, start, end);
688            }
689    
690            /**
691            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63;.
692            *
693            * <p>
694            * 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.
695            * </p>
696            *
697            * @param groupId the group ID
698            * @param start the lower bound of the range of d d m structures
699            * @param end the upper bound of the range of d d m structures (not inclusive)
700            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
701            * @return the ordered range of matching d d m structures that the user has permission to view
702            * @throws SystemException if a system exception occurred
703            */
704            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
705                    long groupId, int start, int end,
706                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
707                    throws com.liferay.portal.kernel.exception.SystemException {
708                    return getPersistence()
709                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
710            }
711    
712            /**
713            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63;.
714            *
715            * @param structureId the primary key of the current d d m structure
716            * @param groupId the group ID
717            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
718            * @return the previous, current, and next d d m structure
719            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
720            * @throws SystemException if a system exception occurred
721            */
722            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByGroupId_PrevAndNext(
723                    long structureId, long groupId,
724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
725                    throws com.liferay.portal.kernel.exception.SystemException,
726                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
727                    return getPersistence()
728                                       .filterFindByGroupId_PrevAndNext(structureId, groupId,
729                            orderByComparator);
730            }
731    
732            /**
733            * Returns all the d d m structures that the user has permission to view where groupId = any &#63;.
734            *
735            * @param groupIds the group IDs
736            * @return the matching d d m structures that the user has permission to view
737            * @throws SystemException if a system exception occurred
738            */
739            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
740                    long[] groupIds)
741                    throws com.liferay.portal.kernel.exception.SystemException {
742                    return getPersistence().filterFindByGroupId(groupIds);
743            }
744    
745            /**
746            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63;.
747            *
748            * <p>
749            * 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.
750            * </p>
751            *
752            * @param groupIds the group IDs
753            * @param start the lower bound of the range of d d m structures
754            * @param end the upper bound of the range of d d m structures (not inclusive)
755            * @return the range of matching d d m structures that the user has permission to view
756            * @throws SystemException if a system exception occurred
757            */
758            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
759                    long[] groupIds, int start, int end)
760                    throws com.liferay.portal.kernel.exception.SystemException {
761                    return getPersistence().filterFindByGroupId(groupIds, start, end);
762            }
763    
764            /**
765            * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any &#63;.
766            *
767            * <p>
768            * 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.
769            * </p>
770            *
771            * @param groupIds the group IDs
772            * @param start the lower bound of the range of d d m structures
773            * @param end the upper bound of the range of d d m structures (not inclusive)
774            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
775            * @return the ordered range of matching d d m structures that the user has permission to view
776            * @throws SystemException if a system exception occurred
777            */
778            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
779                    long[] groupIds, int start, int end,
780                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
781                    throws com.liferay.portal.kernel.exception.SystemException {
782                    return getPersistence()
783                                       .filterFindByGroupId(groupIds, start, end, orderByComparator);
784            }
785    
786            /**
787            * Returns all the d d m structures where groupId = any &#63;.
788            *
789            * <p>
790            * 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.
791            * </p>
792            *
793            * @param groupIds the group IDs
794            * @return the matching d d m structures
795            * @throws SystemException if a system exception occurred
796            */
797            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
798                    long[] groupIds)
799                    throws com.liferay.portal.kernel.exception.SystemException {
800                    return getPersistence().findByGroupId(groupIds);
801            }
802    
803            /**
804            * Returns a range of all the d d m structures where groupId = any &#63;.
805            *
806            * <p>
807            * 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.
808            * </p>
809            *
810            * @param groupIds the group IDs
811            * @param start the lower bound of the range of d d m structures
812            * @param end the upper bound of the range of d d m structures (not inclusive)
813            * @return the range of matching d d m structures
814            * @throws SystemException if a system exception occurred
815            */
816            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
817                    long[] groupIds, int start, int end)
818                    throws com.liferay.portal.kernel.exception.SystemException {
819                    return getPersistence().findByGroupId(groupIds, start, end);
820            }
821    
822            /**
823            * Returns an ordered range of all the d d m structures where groupId = any &#63;.
824            *
825            * <p>
826            * 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.
827            * </p>
828            *
829            * @param groupIds the group IDs
830            * @param start the lower bound of the range of d d m structures
831            * @param end the upper bound of the range of d d m structures (not inclusive)
832            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
833            * @return the ordered range of matching d d m structures
834            * @throws SystemException if a system exception occurred
835            */
836            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
837                    long[] groupIds, int start, int end,
838                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
839                    throws com.liferay.portal.kernel.exception.SystemException {
840                    return getPersistence()
841                                       .findByGroupId(groupIds, start, end, orderByComparator);
842            }
843    
844            /**
845            * Removes all the d d m structures where groupId = &#63; from the database.
846            *
847            * @param groupId the group ID
848            * @throws SystemException if a system exception occurred
849            */
850            public static void removeByGroupId(long groupId)
851                    throws com.liferay.portal.kernel.exception.SystemException {
852                    getPersistence().removeByGroupId(groupId);
853            }
854    
855            /**
856            * Returns the number of d d m structures where groupId = &#63;.
857            *
858            * @param groupId the group ID
859            * @return the number of matching d d m structures
860            * @throws SystemException if a system exception occurred
861            */
862            public static int countByGroupId(long groupId)
863                    throws com.liferay.portal.kernel.exception.SystemException {
864                    return getPersistence().countByGroupId(groupId);
865            }
866    
867            /**
868            * Returns the number of d d m structures where groupId = any &#63;.
869            *
870            * @param groupIds the group IDs
871            * @return the number of matching d d m structures
872            * @throws SystemException if a system exception occurred
873            */
874            public static int countByGroupId(long[] groupIds)
875                    throws com.liferay.portal.kernel.exception.SystemException {
876                    return getPersistence().countByGroupId(groupIds);
877            }
878    
879            /**
880            * Returns the number of d d m structures that the user has permission to view where groupId = &#63;.
881            *
882            * @param groupId the group ID
883            * @return the number of matching d d m structures that the user has permission to view
884            * @throws SystemException if a system exception occurred
885            */
886            public static int filterCountByGroupId(long groupId)
887                    throws com.liferay.portal.kernel.exception.SystemException {
888                    return getPersistence().filterCountByGroupId(groupId);
889            }
890    
891            /**
892            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63;.
893            *
894            * @param groupIds the group IDs
895            * @return the number of matching d d m structures that the user has permission to view
896            * @throws SystemException if a system exception occurred
897            */
898            public static int filterCountByGroupId(long[] groupIds)
899                    throws com.liferay.portal.kernel.exception.SystemException {
900                    return getPersistence().filterCountByGroupId(groupIds);
901            }
902    
903            /**
904            * Returns all the d d m structures where parentStructureId = &#63;.
905            *
906            * @param parentStructureId the parent structure ID
907            * @return the matching d d m structures
908            * @throws SystemException if a system exception occurred
909            */
910            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByParentStructureId(
911                    long parentStructureId)
912                    throws com.liferay.portal.kernel.exception.SystemException {
913                    return getPersistence().findByParentStructureId(parentStructureId);
914            }
915    
916            /**
917            * Returns a range of all the d d m structures where parentStructureId = &#63;.
918            *
919            * <p>
920            * 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.
921            * </p>
922            *
923            * @param parentStructureId the parent structure ID
924            * @param start the lower bound of the range of d d m structures
925            * @param end the upper bound of the range of d d m structures (not inclusive)
926            * @return the range of matching d d m structures
927            * @throws SystemException if a system exception occurred
928            */
929            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByParentStructureId(
930                    long parentStructureId, int start, int end)
931                    throws com.liferay.portal.kernel.exception.SystemException {
932                    return getPersistence()
933                                       .findByParentStructureId(parentStructureId, start, end);
934            }
935    
936            /**
937            * Returns an ordered range of all the d d m structures where parentStructureId = &#63;.
938            *
939            * <p>
940            * 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.
941            * </p>
942            *
943            * @param parentStructureId the parent structure ID
944            * @param start the lower bound of the range of d d m structures
945            * @param end the upper bound of the range of d d m structures (not inclusive)
946            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
947            * @return the ordered range of matching d d m structures
948            * @throws SystemException if a system exception occurred
949            */
950            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByParentStructureId(
951                    long parentStructureId, int start, int end,
952                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
953                    throws com.liferay.portal.kernel.exception.SystemException {
954                    return getPersistence()
955                                       .findByParentStructureId(parentStructureId, start, end,
956                            orderByComparator);
957            }
958    
959            /**
960            * Returns the first d d m structure in the ordered set where parentStructureId = &#63;.
961            *
962            * @param parentStructureId the parent structure ID
963            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
964            * @return the first matching d d m structure
965            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
966            * @throws SystemException if a system exception occurred
967            */
968            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByParentStructureId_First(
969                    long parentStructureId,
970                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
971                    throws com.liferay.portal.kernel.exception.SystemException,
972                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
973                    return getPersistence()
974                                       .findByParentStructureId_First(parentStructureId,
975                            orderByComparator);
976            }
977    
978            /**
979            * Returns the first d d m structure in the ordered set where parentStructureId = &#63;.
980            *
981            * @param parentStructureId the parent structure ID
982            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
983            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
984            * @throws SystemException if a system exception occurred
985            */
986            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByParentStructureId_First(
987                    long parentStructureId,
988                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
989                    throws com.liferay.portal.kernel.exception.SystemException {
990                    return getPersistence()
991                                       .fetchByParentStructureId_First(parentStructureId,
992                            orderByComparator);
993            }
994    
995            /**
996            * Returns the last d d m structure in the ordered set where parentStructureId = &#63;.
997            *
998            * @param parentStructureId the parent structure ID
999            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1000            * @return the last matching d d m structure
1001            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1002            * @throws SystemException if a system exception occurred
1003            */
1004            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByParentStructureId_Last(
1005                    long parentStructureId,
1006                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1007                    throws com.liferay.portal.kernel.exception.SystemException,
1008                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1009                    return getPersistence()
1010                                       .findByParentStructureId_Last(parentStructureId,
1011                            orderByComparator);
1012            }
1013    
1014            /**
1015            * Returns the last d d m structure in the ordered set where parentStructureId = &#63;.
1016            *
1017            * @param parentStructureId the parent structure ID
1018            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1019            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1020            * @throws SystemException if a system exception occurred
1021            */
1022            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByParentStructureId_Last(
1023                    long parentStructureId,
1024                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1025                    throws com.liferay.portal.kernel.exception.SystemException {
1026                    return getPersistence()
1027                                       .fetchByParentStructureId_Last(parentStructureId,
1028                            orderByComparator);
1029            }
1030    
1031            /**
1032            * Returns the d d m structures before and after the current d d m structure in the ordered set where parentStructureId = &#63;.
1033            *
1034            * @param structureId the primary key of the current d d m structure
1035            * @param parentStructureId the parent structure ID
1036            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1037            * @return the previous, current, and next d d m structure
1038            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1039            * @throws SystemException if a system exception occurred
1040            */
1041            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByParentStructureId_PrevAndNext(
1042                    long structureId, long parentStructureId,
1043                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1044                    throws com.liferay.portal.kernel.exception.SystemException,
1045                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1046                    return getPersistence()
1047                                       .findByParentStructureId_PrevAndNext(structureId,
1048                            parentStructureId, orderByComparator);
1049            }
1050    
1051            /**
1052            * Removes all the d d m structures where parentStructureId = &#63; from the database.
1053            *
1054            * @param parentStructureId the parent structure ID
1055            * @throws SystemException if a system exception occurred
1056            */
1057            public static void removeByParentStructureId(long parentStructureId)
1058                    throws com.liferay.portal.kernel.exception.SystemException {
1059                    getPersistence().removeByParentStructureId(parentStructureId);
1060            }
1061    
1062            /**
1063            * Returns the number of d d m structures where parentStructureId = &#63;.
1064            *
1065            * @param parentStructureId the parent structure ID
1066            * @return the number of matching d d m structures
1067            * @throws SystemException if a system exception occurred
1068            */
1069            public static int countByParentStructureId(long parentStructureId)
1070                    throws com.liferay.portal.kernel.exception.SystemException {
1071                    return getPersistence().countByParentStructureId(parentStructureId);
1072            }
1073    
1074            /**
1075            * Returns all the d d m structures where classNameId = &#63;.
1076            *
1077            * @param classNameId the class name ID
1078            * @return the matching d d m structures
1079            * @throws SystemException if a system exception occurred
1080            */
1081            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
1082                    long classNameId)
1083                    throws com.liferay.portal.kernel.exception.SystemException {
1084                    return getPersistence().findByClassNameId(classNameId);
1085            }
1086    
1087            /**
1088            * Returns a range of all the d d m structures where classNameId = &#63;.
1089            *
1090            * <p>
1091            * 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.
1092            * </p>
1093            *
1094            * @param classNameId the class name ID
1095            * @param start the lower bound of the range of d d m structures
1096            * @param end the upper bound of the range of d d m structures (not inclusive)
1097            * @return the range of matching d d m structures
1098            * @throws SystemException if a system exception occurred
1099            */
1100            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
1101                    long classNameId, int start, int end)
1102                    throws com.liferay.portal.kernel.exception.SystemException {
1103                    return getPersistence().findByClassNameId(classNameId, start, end);
1104            }
1105    
1106            /**
1107            * Returns an ordered range of all the d d m structures where classNameId = &#63;.
1108            *
1109            * <p>
1110            * 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.
1111            * </p>
1112            *
1113            * @param classNameId the class name ID
1114            * @param start the lower bound of the range of d d m structures
1115            * @param end the upper bound of the range of d d m structures (not inclusive)
1116            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1117            * @return the ordered range of matching d d m structures
1118            * @throws SystemException if a system exception occurred
1119            */
1120            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
1121                    long classNameId, int start, int end,
1122                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1123                    throws com.liferay.portal.kernel.exception.SystemException {
1124                    return getPersistence()
1125                                       .findByClassNameId(classNameId, start, end, orderByComparator);
1126            }
1127    
1128            /**
1129            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
1130            *
1131            * @param classNameId the class name ID
1132            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1133            * @return the first matching d d m structure
1134            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1135            * @throws SystemException if a system exception occurred
1136            */
1137            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_First(
1138                    long classNameId,
1139                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1140                    throws com.liferay.portal.kernel.exception.SystemException,
1141                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1142                    return getPersistence()
1143                                       .findByClassNameId_First(classNameId, orderByComparator);
1144            }
1145    
1146            /**
1147            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
1148            *
1149            * @param classNameId the class name ID
1150            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1151            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1152            * @throws SystemException if a system exception occurred
1153            */
1154            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_First(
1155                    long classNameId,
1156                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1157                    throws com.liferay.portal.kernel.exception.SystemException {
1158                    return getPersistence()
1159                                       .fetchByClassNameId_First(classNameId, orderByComparator);
1160            }
1161    
1162            /**
1163            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
1164            *
1165            * @param classNameId the class name ID
1166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1167            * @return the last matching d d m structure
1168            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1169            * @throws SystemException if a system exception occurred
1170            */
1171            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_Last(
1172                    long classNameId,
1173                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1174                    throws com.liferay.portal.kernel.exception.SystemException,
1175                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1176                    return getPersistence()
1177                                       .findByClassNameId_Last(classNameId, orderByComparator);
1178            }
1179    
1180            /**
1181            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
1182            *
1183            * @param classNameId the class name ID
1184            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1185            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1186            * @throws SystemException if a system exception occurred
1187            */
1188            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_Last(
1189                    long classNameId,
1190                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1191                    throws com.liferay.portal.kernel.exception.SystemException {
1192                    return getPersistence()
1193                                       .fetchByClassNameId_Last(classNameId, orderByComparator);
1194            }
1195    
1196            /**
1197            * Returns the d d m structures before and after the current d d m structure in the ordered set where classNameId = &#63;.
1198            *
1199            * @param structureId the primary key of the current d d m structure
1200            * @param classNameId the class name ID
1201            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1202            * @return the previous, current, and next d d m structure
1203            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1204            * @throws SystemException if a system exception occurred
1205            */
1206            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByClassNameId_PrevAndNext(
1207                    long structureId, long classNameId,
1208                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1209                    throws com.liferay.portal.kernel.exception.SystemException,
1210                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1211                    return getPersistence()
1212                                       .findByClassNameId_PrevAndNext(structureId, classNameId,
1213                            orderByComparator);
1214            }
1215    
1216            /**
1217            * Removes all the d d m structures where classNameId = &#63; from the database.
1218            *
1219            * @param classNameId the class name ID
1220            * @throws SystemException if a system exception occurred
1221            */
1222            public static void removeByClassNameId(long classNameId)
1223                    throws com.liferay.portal.kernel.exception.SystemException {
1224                    getPersistence().removeByClassNameId(classNameId);
1225            }
1226    
1227            /**
1228            * Returns the number of d d m structures where classNameId = &#63;.
1229            *
1230            * @param classNameId the class name ID
1231            * @return the number of matching d d m structures
1232            * @throws SystemException if a system exception occurred
1233            */
1234            public static int countByClassNameId(long classNameId)
1235                    throws com.liferay.portal.kernel.exception.SystemException {
1236                    return getPersistence().countByClassNameId(classNameId);
1237            }
1238    
1239            /**
1240            * Returns all the d d m structures where structureKey = &#63;.
1241            *
1242            * @param structureKey the structure key
1243            * @return the matching d d m structures
1244            * @throws SystemException if a system exception occurred
1245            */
1246            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
1247                    java.lang.String structureKey)
1248                    throws com.liferay.portal.kernel.exception.SystemException {
1249                    return getPersistence().findByStructureKey(structureKey);
1250            }
1251    
1252            /**
1253            * Returns a range of all the d d m structures where structureKey = &#63;.
1254            *
1255            * <p>
1256            * 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.
1257            * </p>
1258            *
1259            * @param structureKey the structure key
1260            * @param start the lower bound of the range of d d m structures
1261            * @param end the upper bound of the range of d d m structures (not inclusive)
1262            * @return the range of matching d d m structures
1263            * @throws SystemException if a system exception occurred
1264            */
1265            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
1266                    java.lang.String structureKey, int start, int end)
1267                    throws com.liferay.portal.kernel.exception.SystemException {
1268                    return getPersistence().findByStructureKey(structureKey, start, end);
1269            }
1270    
1271            /**
1272            * Returns an ordered range of all the d d m structures where structureKey = &#63;.
1273            *
1274            * <p>
1275            * 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.
1276            * </p>
1277            *
1278            * @param structureKey the structure key
1279            * @param start the lower bound of the range of d d m structures
1280            * @param end the upper bound of the range of d d m structures (not inclusive)
1281            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1282            * @return the ordered range of matching d d m structures
1283            * @throws SystemException if a system exception occurred
1284            */
1285            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
1286                    java.lang.String structureKey, int start, int end,
1287                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1288                    throws com.liferay.portal.kernel.exception.SystemException {
1289                    return getPersistence()
1290                                       .findByStructureKey(structureKey, start, end,
1291                            orderByComparator);
1292            }
1293    
1294            /**
1295            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
1296            *
1297            * @param structureKey the structure key
1298            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1299            * @return the first matching d d m structure
1300            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1301            * @throws SystemException if a system exception occurred
1302            */
1303            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_First(
1304                    java.lang.String structureKey,
1305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1306                    throws com.liferay.portal.kernel.exception.SystemException,
1307                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1308                    return getPersistence()
1309                                       .findByStructureKey_First(structureKey, orderByComparator);
1310            }
1311    
1312            /**
1313            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
1314            *
1315            * @param structureKey the structure key
1316            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1317            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1318            * @throws SystemException if a system exception occurred
1319            */
1320            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_First(
1321                    java.lang.String structureKey,
1322                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1323                    throws com.liferay.portal.kernel.exception.SystemException {
1324                    return getPersistence()
1325                                       .fetchByStructureKey_First(structureKey, orderByComparator);
1326            }
1327    
1328            /**
1329            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
1330            *
1331            * @param structureKey the structure key
1332            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1333            * @return the last matching d d m structure
1334            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1335            * @throws SystemException if a system exception occurred
1336            */
1337            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_Last(
1338                    java.lang.String structureKey,
1339                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1340                    throws com.liferay.portal.kernel.exception.SystemException,
1341                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1342                    return getPersistence()
1343                                       .findByStructureKey_Last(structureKey, orderByComparator);
1344            }
1345    
1346            /**
1347            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
1348            *
1349            * @param structureKey the structure key
1350            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1351            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1352            * @throws SystemException if a system exception occurred
1353            */
1354            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_Last(
1355                    java.lang.String structureKey,
1356                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1357                    throws com.liferay.portal.kernel.exception.SystemException {
1358                    return getPersistence()
1359                                       .fetchByStructureKey_Last(structureKey, orderByComparator);
1360            }
1361    
1362            /**
1363            * Returns the d d m structures before and after the current d d m structure in the ordered set where structureKey = &#63;.
1364            *
1365            * @param structureId the primary key of the current d d m structure
1366            * @param structureKey the structure key
1367            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1368            * @return the previous, current, and next d d m structure
1369            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1370            * @throws SystemException if a system exception occurred
1371            */
1372            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByStructureKey_PrevAndNext(
1373                    long structureId, java.lang.String structureKey,
1374                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1375                    throws com.liferay.portal.kernel.exception.SystemException,
1376                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1377                    return getPersistence()
1378                                       .findByStructureKey_PrevAndNext(structureId, structureKey,
1379                            orderByComparator);
1380            }
1381    
1382            /**
1383            * Removes all the d d m structures where structureKey = &#63; from the database.
1384            *
1385            * @param structureKey the structure key
1386            * @throws SystemException if a system exception occurred
1387            */
1388            public static void removeByStructureKey(java.lang.String structureKey)
1389                    throws com.liferay.portal.kernel.exception.SystemException {
1390                    getPersistence().removeByStructureKey(structureKey);
1391            }
1392    
1393            /**
1394            * Returns the number of d d m structures where structureKey = &#63;.
1395            *
1396            * @param structureKey the structure key
1397            * @return the number of matching d d m structures
1398            * @throws SystemException if a system exception occurred
1399            */
1400            public static int countByStructureKey(java.lang.String structureKey)
1401                    throws com.liferay.portal.kernel.exception.SystemException {
1402                    return getPersistence().countByStructureKey(structureKey);
1403            }
1404    
1405            /**
1406            * Returns all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1407            *
1408            * @param groupId the group ID
1409            * @param parentStructureId the parent structure ID
1410            * @return the matching d d m structures
1411            * @throws SystemException if a system exception occurred
1412            */
1413            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P(
1414                    long groupId, long parentStructureId)
1415                    throws com.liferay.portal.kernel.exception.SystemException {
1416                    return getPersistence().findByG_P(groupId, parentStructureId);
1417            }
1418    
1419            /**
1420            * Returns a range of all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1421            *
1422            * <p>
1423            * 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.
1424            * </p>
1425            *
1426            * @param groupId the group ID
1427            * @param parentStructureId the parent structure ID
1428            * @param start the lower bound of the range of d d m structures
1429            * @param end the upper bound of the range of d d m structures (not inclusive)
1430            * @return the range of matching d d m structures
1431            * @throws SystemException if a system exception occurred
1432            */
1433            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P(
1434                    long groupId, long parentStructureId, int start, int end)
1435                    throws com.liferay.portal.kernel.exception.SystemException {
1436                    return getPersistence().findByG_P(groupId, parentStructureId, start, end);
1437            }
1438    
1439            /**
1440            * Returns an ordered range of all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1441            *
1442            * <p>
1443            * 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.
1444            * </p>
1445            *
1446            * @param groupId the group ID
1447            * @param parentStructureId the parent structure ID
1448            * @param start the lower bound of the range of d d m structures
1449            * @param end the upper bound of the range of d d m structures (not inclusive)
1450            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1451            * @return the ordered range of matching d d m structures
1452            * @throws SystemException if a system exception occurred
1453            */
1454            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P(
1455                    long groupId, long parentStructureId, int start, int end,
1456                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1457                    throws com.liferay.portal.kernel.exception.SystemException {
1458                    return getPersistence()
1459                                       .findByG_P(groupId, parentStructureId, start, end,
1460                            orderByComparator);
1461            }
1462    
1463            /**
1464            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1465            *
1466            * @param groupId the group ID
1467            * @param parentStructureId the parent structure ID
1468            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1469            * @return the first matching d d m structure
1470            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1471            * @throws SystemException if a system exception occurred
1472            */
1473            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_First(
1474                    long groupId, long parentStructureId,
1475                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1476                    throws com.liferay.portal.kernel.exception.SystemException,
1477                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1478                    return getPersistence()
1479                                       .findByG_P_First(groupId, parentStructureId,
1480                            orderByComparator);
1481            }
1482    
1483            /**
1484            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1485            *
1486            * @param groupId the group ID
1487            * @param parentStructureId the parent structure ID
1488            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1489            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1490            * @throws SystemException if a system exception occurred
1491            */
1492            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_First(
1493                    long groupId, long parentStructureId,
1494                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1495                    throws com.liferay.portal.kernel.exception.SystemException {
1496                    return getPersistence()
1497                                       .fetchByG_P_First(groupId, parentStructureId,
1498                            orderByComparator);
1499            }
1500    
1501            /**
1502            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1503            *
1504            * @param groupId the group ID
1505            * @param parentStructureId the parent structure ID
1506            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1507            * @return the last matching d d m structure
1508            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1509            * @throws SystemException if a system exception occurred
1510            */
1511            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_Last(
1512                    long groupId, long parentStructureId,
1513                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1514                    throws com.liferay.portal.kernel.exception.SystemException,
1515                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1516                    return getPersistence()
1517                                       .findByG_P_Last(groupId, parentStructureId, orderByComparator);
1518            }
1519    
1520            /**
1521            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1522            *
1523            * @param groupId the group ID
1524            * @param parentStructureId the parent structure ID
1525            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1526            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1527            * @throws SystemException if a system exception occurred
1528            */
1529            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_Last(
1530                    long groupId, long parentStructureId,
1531                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1532                    throws com.liferay.portal.kernel.exception.SystemException {
1533                    return getPersistence()
1534                                       .fetchByG_P_Last(groupId, parentStructureId,
1535                            orderByComparator);
1536            }
1537    
1538            /**
1539            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1540            *
1541            * @param structureId the primary key of the current d d m structure
1542            * @param groupId the group ID
1543            * @param parentStructureId the parent structure ID
1544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1545            * @return the previous, current, and next d d m structure
1546            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1547            * @throws SystemException if a system exception occurred
1548            */
1549            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_P_PrevAndNext(
1550                    long structureId, long groupId, long parentStructureId,
1551                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1552                    throws com.liferay.portal.kernel.exception.SystemException,
1553                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1554                    return getPersistence()
1555                                       .findByG_P_PrevAndNext(structureId, groupId,
1556                            parentStructureId, orderByComparator);
1557            }
1558    
1559            /**
1560            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1561            *
1562            * @param groupId the group ID
1563            * @param parentStructureId the parent structure ID
1564            * @return the matching d d m structures that the user has permission to view
1565            * @throws SystemException if a system exception occurred
1566            */
1567            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1568                    long groupId, long parentStructureId)
1569                    throws com.liferay.portal.kernel.exception.SystemException {
1570                    return getPersistence().filterFindByG_P(groupId, parentStructureId);
1571            }
1572    
1573            /**
1574            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1575            *
1576            * <p>
1577            * 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.
1578            * </p>
1579            *
1580            * @param groupId the group ID
1581            * @param parentStructureId the parent structure ID
1582            * @param start the lower bound of the range of d d m structures
1583            * @param end the upper bound of the range of d d m structures (not inclusive)
1584            * @return the range of matching d d m structures that the user has permission to view
1585            * @throws SystemException if a system exception occurred
1586            */
1587            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1588                    long groupId, long parentStructureId, int start, int end)
1589                    throws com.liferay.portal.kernel.exception.SystemException {
1590                    return getPersistence()
1591                                       .filterFindByG_P(groupId, parentStructureId, start, end);
1592            }
1593    
1594            /**
1595            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
1596            *
1597            * <p>
1598            * 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.
1599            * </p>
1600            *
1601            * @param groupId the group ID
1602            * @param parentStructureId the parent structure ID
1603            * @param start the lower bound of the range of d d m structures
1604            * @param end the upper bound of the range of d d m structures (not inclusive)
1605            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1606            * @return the ordered range of matching d d m structures that the user has permission to view
1607            * @throws SystemException if a system exception occurred
1608            */
1609            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1610                    long groupId, long parentStructureId, int start, int end,
1611                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1612                    throws com.liferay.portal.kernel.exception.SystemException {
1613                    return getPersistence()
1614                                       .filterFindByG_P(groupId, parentStructureId, start, end,
1615                            orderByComparator);
1616            }
1617    
1618            /**
1619            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1620            *
1621            * @param structureId the primary key of the current d d m structure
1622            * @param groupId the group ID
1623            * @param parentStructureId the parent structure ID
1624            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1625            * @return the previous, current, and next d d m structure
1626            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1627            * @throws SystemException if a system exception occurred
1628            */
1629            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_P_PrevAndNext(
1630                    long structureId, long groupId, long parentStructureId,
1631                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1632                    throws com.liferay.portal.kernel.exception.SystemException,
1633                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1634                    return getPersistence()
1635                                       .filterFindByG_P_PrevAndNext(structureId, groupId,
1636                            parentStructureId, orderByComparator);
1637            }
1638    
1639            /**
1640            * Removes all the d d m structures where groupId = &#63; and parentStructureId = &#63; from the database.
1641            *
1642            * @param groupId the group ID
1643            * @param parentStructureId the parent structure ID
1644            * @throws SystemException if a system exception occurred
1645            */
1646            public static void removeByG_P(long groupId, long parentStructureId)
1647                    throws com.liferay.portal.kernel.exception.SystemException {
1648                    getPersistence().removeByG_P(groupId, parentStructureId);
1649            }
1650    
1651            /**
1652            * Returns the number of d d m structures where groupId = &#63; and parentStructureId = &#63;.
1653            *
1654            * @param groupId the group ID
1655            * @param parentStructureId the parent structure ID
1656            * @return the number of matching d d m structures
1657            * @throws SystemException if a system exception occurred
1658            */
1659            public static int countByG_P(long groupId, long parentStructureId)
1660                    throws com.liferay.portal.kernel.exception.SystemException {
1661                    return getPersistence().countByG_P(groupId, parentStructureId);
1662            }
1663    
1664            /**
1665            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1666            *
1667            * @param groupId the group ID
1668            * @param parentStructureId the parent structure ID
1669            * @return the number of matching d d m structures that the user has permission to view
1670            * @throws SystemException if a system exception occurred
1671            */
1672            public static int filterCountByG_P(long groupId, long parentStructureId)
1673                    throws com.liferay.portal.kernel.exception.SystemException {
1674                    return getPersistence().filterCountByG_P(groupId, parentStructureId);
1675            }
1676    
1677            /**
1678            * Returns all the d d m structures where groupId = &#63; and classNameId = &#63;.
1679            *
1680            * @param groupId the group ID
1681            * @param classNameId the class name ID
1682            * @return the matching d d m structures
1683            * @throws SystemException if a system exception occurred
1684            */
1685            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1686                    long groupId, long classNameId)
1687                    throws com.liferay.portal.kernel.exception.SystemException {
1688                    return getPersistence().findByG_C(groupId, classNameId);
1689            }
1690    
1691            /**
1692            * Returns a range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1693            *
1694            * <p>
1695            * 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.
1696            * </p>
1697            *
1698            * @param groupId the group ID
1699            * @param classNameId the class name ID
1700            * @param start the lower bound of the range of d d m structures
1701            * @param end the upper bound of the range of d d m structures (not inclusive)
1702            * @return the range of matching d d m structures
1703            * @throws SystemException if a system exception occurred
1704            */
1705            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1706                    long groupId, long classNameId, int start, int end)
1707                    throws com.liferay.portal.kernel.exception.SystemException {
1708                    return getPersistence().findByG_C(groupId, classNameId, start, end);
1709            }
1710    
1711            /**
1712            * Returns an ordered range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1713            *
1714            * <p>
1715            * 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.
1716            * </p>
1717            *
1718            * @param groupId the group ID
1719            * @param classNameId the class name ID
1720            * @param start the lower bound of the range of d d m structures
1721            * @param end the upper bound of the range of d d m structures (not inclusive)
1722            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1723            * @return the ordered range of matching d d m structures
1724            * @throws SystemException if a system exception occurred
1725            */
1726            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1727                    long groupId, long classNameId, int start, int end,
1728                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1729                    throws com.liferay.portal.kernel.exception.SystemException {
1730                    return getPersistence()
1731                                       .findByG_C(groupId, classNameId, start, end,
1732                            orderByComparator);
1733            }
1734    
1735            /**
1736            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1737            *
1738            * @param groupId the group ID
1739            * @param classNameId the class name ID
1740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1741            * @return the first matching d d m structure
1742            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1743            * @throws SystemException if a system exception occurred
1744            */
1745            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_First(
1746                    long groupId, long classNameId,
1747                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1748                    throws com.liferay.portal.kernel.exception.SystemException,
1749                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1750                    return getPersistence()
1751                                       .findByG_C_First(groupId, classNameId, orderByComparator);
1752            }
1753    
1754            /**
1755            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1756            *
1757            * @param groupId the group ID
1758            * @param classNameId the class name ID
1759            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1760            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1761            * @throws SystemException if a system exception occurred
1762            */
1763            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_First(
1764                    long groupId, long classNameId,
1765                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1766                    throws com.liferay.portal.kernel.exception.SystemException {
1767                    return getPersistence()
1768                                       .fetchByG_C_First(groupId, classNameId, orderByComparator);
1769            }
1770    
1771            /**
1772            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1773            *
1774            * @param groupId the group ID
1775            * @param classNameId the class name ID
1776            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1777            * @return the last matching d d m structure
1778            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1779            * @throws SystemException if a system exception occurred
1780            */
1781            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_Last(
1782                    long groupId, long classNameId,
1783                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1784                    throws com.liferay.portal.kernel.exception.SystemException,
1785                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1786                    return getPersistence()
1787                                       .findByG_C_Last(groupId, classNameId, orderByComparator);
1788            }
1789    
1790            /**
1791            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1792            *
1793            * @param groupId the group ID
1794            * @param classNameId the class name ID
1795            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1796            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1797            * @throws SystemException if a system exception occurred
1798            */
1799            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_Last(
1800                    long groupId, long classNameId,
1801                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1802                    throws com.liferay.portal.kernel.exception.SystemException {
1803                    return getPersistence()
1804                                       .fetchByG_C_Last(groupId, classNameId, orderByComparator);
1805            }
1806    
1807            /**
1808            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1809            *
1810            * @param structureId the primary key of the current d d m structure
1811            * @param groupId the group ID
1812            * @param classNameId the class name ID
1813            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1814            * @return the previous, current, and next d d m structure
1815            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1816            * @throws SystemException if a system exception occurred
1817            */
1818            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_C_PrevAndNext(
1819                    long structureId, long groupId, long classNameId,
1820                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1821                    throws com.liferay.portal.kernel.exception.SystemException,
1822                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1823                    return getPersistence()
1824                                       .findByG_C_PrevAndNext(structureId, groupId, classNameId,
1825                            orderByComparator);
1826            }
1827    
1828            /**
1829            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1830            *
1831            * @param groupId the group ID
1832            * @param classNameId the class name ID
1833            * @return the matching d d m structures that the user has permission to view
1834            * @throws SystemException if a system exception occurred
1835            */
1836            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1837                    long groupId, long classNameId)
1838                    throws com.liferay.portal.kernel.exception.SystemException {
1839                    return getPersistence().filterFindByG_C(groupId, classNameId);
1840            }
1841    
1842            /**
1843            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1844            *
1845            * <p>
1846            * 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.
1847            * </p>
1848            *
1849            * @param groupId the group ID
1850            * @param classNameId the class name ID
1851            * @param start the lower bound of the range of d d m structures
1852            * @param end the upper bound of the range of d d m structures (not inclusive)
1853            * @return the range of matching d d m structures that the user has permission to view
1854            * @throws SystemException if a system exception occurred
1855            */
1856            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1857                    long groupId, long classNameId, int start, int end)
1858                    throws com.liferay.portal.kernel.exception.SystemException {
1859                    return getPersistence().filterFindByG_C(groupId, classNameId, start, end);
1860            }
1861    
1862            /**
1863            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and classNameId = &#63;.
1864            *
1865            * <p>
1866            * 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.
1867            * </p>
1868            *
1869            * @param groupId the group ID
1870            * @param classNameId the class name ID
1871            * @param start the lower bound of the range of d d m structures
1872            * @param end the upper bound of the range of d d m structures (not inclusive)
1873            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1874            * @return the ordered range of matching d d m structures that the user has permission to view
1875            * @throws SystemException if a system exception occurred
1876            */
1877            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1878                    long groupId, long classNameId, int start, int end,
1879                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1880                    throws com.liferay.portal.kernel.exception.SystemException {
1881                    return getPersistence()
1882                                       .filterFindByG_C(groupId, classNameId, start, end,
1883                            orderByComparator);
1884            }
1885    
1886            /**
1887            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1888            *
1889            * @param structureId the primary key of the current d d m structure
1890            * @param groupId the group ID
1891            * @param classNameId the class name ID
1892            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1893            * @return the previous, current, and next d d m structure
1894            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1895            * @throws SystemException if a system exception occurred
1896            */
1897            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_C_PrevAndNext(
1898                    long structureId, long groupId, long classNameId,
1899                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1900                    throws com.liferay.portal.kernel.exception.SystemException,
1901                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
1902                    return getPersistence()
1903                                       .filterFindByG_C_PrevAndNext(structureId, groupId,
1904                            classNameId, orderByComparator);
1905            }
1906    
1907            /**
1908            * Returns all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1909            *
1910            * @param groupIds the group IDs
1911            * @param classNameId the class name ID
1912            * @return the matching d d m structures that the user has permission to view
1913            * @throws SystemException if a system exception occurred
1914            */
1915            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1916                    long[] groupIds, long classNameId)
1917                    throws com.liferay.portal.kernel.exception.SystemException {
1918                    return getPersistence().filterFindByG_C(groupIds, classNameId);
1919            }
1920    
1921            /**
1922            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1923            *
1924            * <p>
1925            * 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.
1926            * </p>
1927            *
1928            * @param groupIds the group IDs
1929            * @param classNameId the class name ID
1930            * @param start the lower bound of the range of d d m structures
1931            * @param end the upper bound of the range of d d m structures (not inclusive)
1932            * @return the range of matching d d m structures that the user has permission to view
1933            * @throws SystemException if a system exception occurred
1934            */
1935            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1936                    long[] groupIds, long classNameId, int start, int end)
1937                    throws com.liferay.portal.kernel.exception.SystemException {
1938                    return getPersistence()
1939                                       .filterFindByG_C(groupIds, classNameId, start, end);
1940            }
1941    
1942            /**
1943            * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1944            *
1945            * <p>
1946            * 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.
1947            * </p>
1948            *
1949            * @param groupIds the group IDs
1950            * @param classNameId the class name ID
1951            * @param start the lower bound of the range of d d m structures
1952            * @param end the upper bound of the range of d d m structures (not inclusive)
1953            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1954            * @return the ordered range of matching d d m structures that the user has permission to view
1955            * @throws SystemException if a system exception occurred
1956            */
1957            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1958                    long[] groupIds, long classNameId, int start, int end,
1959                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1960                    throws com.liferay.portal.kernel.exception.SystemException {
1961                    return getPersistence()
1962                                       .filterFindByG_C(groupIds, classNameId, start, end,
1963                            orderByComparator);
1964            }
1965    
1966            /**
1967            * Returns all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1968            *
1969            * <p>
1970            * 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.
1971            * </p>
1972            *
1973            * @param groupIds the group IDs
1974            * @param classNameId the class name ID
1975            * @return the matching d d m structures
1976            * @throws SystemException if a system exception occurred
1977            */
1978            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1979                    long[] groupIds, long classNameId)
1980                    throws com.liferay.portal.kernel.exception.SystemException {
1981                    return getPersistence().findByG_C(groupIds, classNameId);
1982            }
1983    
1984            /**
1985            * Returns a range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1986            *
1987            * <p>
1988            * 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.
1989            * </p>
1990            *
1991            * @param groupIds the group IDs
1992            * @param classNameId the class name ID
1993            * @param start the lower bound of the range of d d m structures
1994            * @param end the upper bound of the range of d d m structures (not inclusive)
1995            * @return the range of matching d d m structures
1996            * @throws SystemException if a system exception occurred
1997            */
1998            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1999                    long[] groupIds, long classNameId, int start, int end)
2000                    throws com.liferay.portal.kernel.exception.SystemException {
2001                    return getPersistence().findByG_C(groupIds, classNameId, start, end);
2002            }
2003    
2004            /**
2005            * Returns an ordered range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
2006            *
2007            * <p>
2008            * 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.
2009            * </p>
2010            *
2011            * @param groupIds the group IDs
2012            * @param classNameId the class name ID
2013            * @param start the lower bound of the range of d d m structures
2014            * @param end the upper bound of the range of d d m structures (not inclusive)
2015            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2016            * @return the ordered range of matching d d m structures
2017            * @throws SystemException if a system exception occurred
2018            */
2019            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
2020                    long[] groupIds, long classNameId, int start, int end,
2021                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2022                    throws com.liferay.portal.kernel.exception.SystemException {
2023                    return getPersistence()
2024                                       .findByG_C(groupIds, classNameId, start, end,
2025                            orderByComparator);
2026            }
2027    
2028            /**
2029            * Removes all the d d m structures where groupId = &#63; and classNameId = &#63; from the database.
2030            *
2031            * @param groupId the group ID
2032            * @param classNameId the class name ID
2033            * @throws SystemException if a system exception occurred
2034            */
2035            public static void removeByG_C(long groupId, long classNameId)
2036                    throws com.liferay.portal.kernel.exception.SystemException {
2037                    getPersistence().removeByG_C(groupId, classNameId);
2038            }
2039    
2040            /**
2041            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63;.
2042            *
2043            * @param groupId the group ID
2044            * @param classNameId the class name ID
2045            * @return the number of matching d d m structures
2046            * @throws SystemException if a system exception occurred
2047            */
2048            public static int countByG_C(long groupId, long classNameId)
2049                    throws com.liferay.portal.kernel.exception.SystemException {
2050                    return getPersistence().countByG_C(groupId, classNameId);
2051            }
2052    
2053            /**
2054            * Returns the number of d d m structures where groupId = any &#63; and classNameId = &#63;.
2055            *
2056            * @param groupIds the group IDs
2057            * @param classNameId the class name ID
2058            * @return the number of matching d d m structures
2059            * @throws SystemException if a system exception occurred
2060            */
2061            public static int countByG_C(long[] groupIds, long classNameId)
2062                    throws com.liferay.portal.kernel.exception.SystemException {
2063                    return getPersistence().countByG_C(groupIds, classNameId);
2064            }
2065    
2066            /**
2067            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
2068            *
2069            * @param groupId the group ID
2070            * @param classNameId the class name ID
2071            * @return the number of matching d d m structures that the user has permission to view
2072            * @throws SystemException if a system exception occurred
2073            */
2074            public static int filterCountByG_C(long groupId, long classNameId)
2075                    throws com.liferay.portal.kernel.exception.SystemException {
2076                    return getPersistence().filterCountByG_C(groupId, classNameId);
2077            }
2078    
2079            /**
2080            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
2081            *
2082            * @param groupIds the group IDs
2083            * @param classNameId the class name ID
2084            * @return the number of matching d d m structures that the user has permission to view
2085            * @throws SystemException if a system exception occurred
2086            */
2087            public static int filterCountByG_C(long[] groupIds, long classNameId)
2088                    throws com.liferay.portal.kernel.exception.SystemException {
2089                    return getPersistence().filterCountByG_C(groupIds, classNameId);
2090            }
2091    
2092            /**
2093            * Returns all the d d m structures where companyId = &#63; and classNameId = &#63;.
2094            *
2095            * @param companyId the company ID
2096            * @param classNameId the class name ID
2097            * @return the matching d d m structures
2098            * @throws SystemException if a system exception occurred
2099            */
2100            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
2101                    long companyId, long classNameId)
2102                    throws com.liferay.portal.kernel.exception.SystemException {
2103                    return getPersistence().findByC_C(companyId, classNameId);
2104            }
2105    
2106            /**
2107            * Returns a range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
2108            *
2109            * <p>
2110            * 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.
2111            * </p>
2112            *
2113            * @param companyId the company ID
2114            * @param classNameId the class name ID
2115            * @param start the lower bound of the range of d d m structures
2116            * @param end the upper bound of the range of d d m structures (not inclusive)
2117            * @return the range of matching d d m structures
2118            * @throws SystemException if a system exception occurred
2119            */
2120            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
2121                    long companyId, long classNameId, int start, int end)
2122                    throws com.liferay.portal.kernel.exception.SystemException {
2123                    return getPersistence().findByC_C(companyId, classNameId, start, end);
2124            }
2125    
2126            /**
2127            * Returns an ordered range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
2128            *
2129            * <p>
2130            * 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.
2131            * </p>
2132            *
2133            * @param companyId the company ID
2134            * @param classNameId the class name ID
2135            * @param start the lower bound of the range of d d m structures
2136            * @param end the upper bound of the range of d d m structures (not inclusive)
2137            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2138            * @return the ordered range of matching d d m structures
2139            * @throws SystemException if a system exception occurred
2140            */
2141            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
2142                    long companyId, long classNameId, int start, int end,
2143                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2144                    throws com.liferay.portal.kernel.exception.SystemException {
2145                    return getPersistence()
2146                                       .findByC_C(companyId, classNameId, start, end,
2147                            orderByComparator);
2148            }
2149    
2150            /**
2151            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2152            *
2153            * @param companyId the company ID
2154            * @param classNameId the class name ID
2155            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2156            * @return the first matching d d m structure
2157            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2158            * @throws SystemException if a system exception occurred
2159            */
2160            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_First(
2161                    long companyId, long classNameId,
2162                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2163                    throws com.liferay.portal.kernel.exception.SystemException,
2164                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2165                    return getPersistence()
2166                                       .findByC_C_First(companyId, classNameId, orderByComparator);
2167            }
2168    
2169            /**
2170            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2171            *
2172            * @param companyId the company ID
2173            * @param classNameId the class name ID
2174            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2175            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2176            * @throws SystemException if a system exception occurred
2177            */
2178            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_First(
2179                    long companyId, long classNameId,
2180                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2181                    throws com.liferay.portal.kernel.exception.SystemException {
2182                    return getPersistence()
2183                                       .fetchByC_C_First(companyId, classNameId, orderByComparator);
2184            }
2185    
2186            /**
2187            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2188            *
2189            * @param companyId the company ID
2190            * @param classNameId the class name ID
2191            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2192            * @return the last matching d d m structure
2193            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2194            * @throws SystemException if a system exception occurred
2195            */
2196            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_Last(
2197                    long companyId, long classNameId,
2198                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2199                    throws com.liferay.portal.kernel.exception.SystemException,
2200                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2201                    return getPersistence()
2202                                       .findByC_C_Last(companyId, classNameId, orderByComparator);
2203            }
2204    
2205            /**
2206            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2207            *
2208            * @param companyId the company ID
2209            * @param classNameId the class name ID
2210            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2211            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2212            * @throws SystemException if a system exception occurred
2213            */
2214            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_Last(
2215                    long companyId, long classNameId,
2216                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2217                    throws com.liferay.portal.kernel.exception.SystemException {
2218                    return getPersistence()
2219                                       .fetchByC_C_Last(companyId, classNameId, orderByComparator);
2220            }
2221    
2222            /**
2223            * Returns the d d m structures before and after the current d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
2224            *
2225            * @param structureId the primary key of the current d d m structure
2226            * @param companyId the company ID
2227            * @param classNameId the class name ID
2228            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2229            * @return the previous, current, and next d d m structure
2230            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2231            * @throws SystemException if a system exception occurred
2232            */
2233            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByC_C_PrevAndNext(
2234                    long structureId, long companyId, long classNameId,
2235                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2236                    throws com.liferay.portal.kernel.exception.SystemException,
2237                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2238                    return getPersistence()
2239                                       .findByC_C_PrevAndNext(structureId, companyId, classNameId,
2240                            orderByComparator);
2241            }
2242    
2243            /**
2244            * Removes all the d d m structures where companyId = &#63; and classNameId = &#63; from the database.
2245            *
2246            * @param companyId the company ID
2247            * @param classNameId the class name ID
2248            * @throws SystemException if a system exception occurred
2249            */
2250            public static void removeByC_C(long companyId, long classNameId)
2251                    throws com.liferay.portal.kernel.exception.SystemException {
2252                    getPersistence().removeByC_C(companyId, classNameId);
2253            }
2254    
2255            /**
2256            * Returns the number of d d m structures where companyId = &#63; and classNameId = &#63;.
2257            *
2258            * @param companyId the company ID
2259            * @param classNameId the class name ID
2260            * @return the number of matching d d m structures
2261            * @throws SystemException if a system exception occurred
2262            */
2263            public static int countByC_C(long companyId, long classNameId)
2264                    throws com.liferay.portal.kernel.exception.SystemException {
2265                    return getPersistence().countByC_C(companyId, classNameId);
2266            }
2267    
2268            /**
2269            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found.
2270            *
2271            * @param groupId the group ID
2272            * @param classNameId the class name ID
2273            * @param structureKey the structure key
2274            * @return the matching d d m structure
2275            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2276            * @throws SystemException if a system exception occurred
2277            */
2278            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_S(
2279                    long groupId, long classNameId, java.lang.String structureKey)
2280                    throws com.liferay.portal.kernel.exception.SystemException,
2281                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2282                    return getPersistence().findByG_C_S(groupId, classNameId, structureKey);
2283            }
2284    
2285            /**
2286            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
2287            *
2288            * @param groupId the group ID
2289            * @param classNameId the class name ID
2290            * @param structureKey the structure key
2291            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2292            * @throws SystemException if a system exception occurred
2293            */
2294            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
2295                    long groupId, long classNameId, java.lang.String structureKey)
2296                    throws com.liferay.portal.kernel.exception.SystemException {
2297                    return getPersistence().fetchByG_C_S(groupId, classNameId, structureKey);
2298            }
2299    
2300            /**
2301            * Returns the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
2302            *
2303            * @param groupId the group ID
2304            * @param classNameId the class name ID
2305            * @param structureKey the structure key
2306            * @param retrieveFromCache whether to use the finder cache
2307            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2308            * @throws SystemException if a system exception occurred
2309            */
2310            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
2311                    long groupId, long classNameId, java.lang.String structureKey,
2312                    boolean retrieveFromCache)
2313                    throws com.liferay.portal.kernel.exception.SystemException {
2314                    return getPersistence()
2315                                       .fetchByG_C_S(groupId, classNameId, structureKey,
2316                            retrieveFromCache);
2317            }
2318    
2319            /**
2320            * Removes the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; from the database.
2321            *
2322            * @param groupId the group ID
2323            * @param classNameId the class name ID
2324            * @param structureKey the structure key
2325            * @return the d d m structure that was removed
2326            * @throws SystemException if a system exception occurred
2327            */
2328            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByG_C_S(
2329                    long groupId, long classNameId, java.lang.String structureKey)
2330                    throws com.liferay.portal.kernel.exception.SystemException,
2331                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2332                    return getPersistence().removeByG_C_S(groupId, classNameId, structureKey);
2333            }
2334    
2335            /**
2336            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63; and structureKey = &#63;.
2337            *
2338            * @param groupId the group ID
2339            * @param classNameId the class name ID
2340            * @param structureKey the structure key
2341            * @return the number of matching d d m structures
2342            * @throws SystemException if a system exception occurred
2343            */
2344            public static int countByG_C_S(long groupId, long classNameId,
2345                    java.lang.String structureKey)
2346                    throws com.liferay.portal.kernel.exception.SystemException {
2347                    return getPersistence().countByG_C_S(groupId, classNameId, structureKey);
2348            }
2349    
2350            /**
2351            * Returns all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2352            *
2353            * @param groupId the group ID
2354            * @param name the name
2355            * @param description the description
2356            * @return the matching d d m structures
2357            * @throws SystemException if a system exception occurred
2358            */
2359            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
2360                    long groupId, java.lang.String name, java.lang.String description)
2361                    throws com.liferay.portal.kernel.exception.SystemException {
2362                    return getPersistence().findByG_N_D(groupId, name, description);
2363            }
2364    
2365            /**
2366            * Returns a range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2367            *
2368            * <p>
2369            * 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.
2370            * </p>
2371            *
2372            * @param groupId the group ID
2373            * @param name the name
2374            * @param description the description
2375            * @param start the lower bound of the range of d d m structures
2376            * @param end the upper bound of the range of d d m structures (not inclusive)
2377            * @return the range of matching d d m structures
2378            * @throws SystemException if a system exception occurred
2379            */
2380            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
2381                    long groupId, java.lang.String name, java.lang.String description,
2382                    int start, int end)
2383                    throws com.liferay.portal.kernel.exception.SystemException {
2384                    return getPersistence()
2385                                       .findByG_N_D(groupId, name, description, start, end);
2386            }
2387    
2388            /**
2389            * Returns an ordered range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2390            *
2391            * <p>
2392            * 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.
2393            * </p>
2394            *
2395            * @param groupId the group ID
2396            * @param name the name
2397            * @param description the description
2398            * @param start the lower bound of the range of d d m structures
2399            * @param end the upper bound of the range of d d m structures (not inclusive)
2400            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2401            * @return the ordered range of matching d d m structures
2402            * @throws SystemException if a system exception occurred
2403            */
2404            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
2405                    long groupId, java.lang.String name, java.lang.String description,
2406                    int start, int end,
2407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2408                    throws com.liferay.portal.kernel.exception.SystemException {
2409                    return getPersistence()
2410                                       .findByG_N_D(groupId, name, description, start, end,
2411                            orderByComparator);
2412            }
2413    
2414            /**
2415            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2416            *
2417            * @param groupId the group ID
2418            * @param name the name
2419            * @param description the description
2420            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2421            * @return the first matching d d m structure
2422            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2423            * @throws SystemException if a system exception occurred
2424            */
2425            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_First(
2426                    long groupId, java.lang.String name, java.lang.String description,
2427                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2428                    throws com.liferay.portal.kernel.exception.SystemException,
2429                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2430                    return getPersistence()
2431                                       .findByG_N_D_First(groupId, name, description,
2432                            orderByComparator);
2433            }
2434    
2435            /**
2436            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2437            *
2438            * @param groupId the group ID
2439            * @param name the name
2440            * @param description the description
2441            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2442            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2443            * @throws SystemException if a system exception occurred
2444            */
2445            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_First(
2446                    long groupId, java.lang.String name, java.lang.String description,
2447                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2448                    throws com.liferay.portal.kernel.exception.SystemException {
2449                    return getPersistence()
2450                                       .fetchByG_N_D_First(groupId, name, description,
2451                            orderByComparator);
2452            }
2453    
2454            /**
2455            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2456            *
2457            * @param groupId the group ID
2458            * @param name the name
2459            * @param description the description
2460            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2461            * @return the last matching d d m structure
2462            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
2463            * @throws SystemException if a system exception occurred
2464            */
2465            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_Last(
2466                    long groupId, java.lang.String name, java.lang.String description,
2467                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2468                    throws com.liferay.portal.kernel.exception.SystemException,
2469                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2470                    return getPersistence()
2471                                       .findByG_N_D_Last(groupId, name, description,
2472                            orderByComparator);
2473            }
2474    
2475            /**
2476            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2477            *
2478            * @param groupId the group ID
2479            * @param name the name
2480            * @param description the description
2481            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2482            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
2483            * @throws SystemException if a system exception occurred
2484            */
2485            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_Last(
2486                    long groupId, java.lang.String name, java.lang.String description,
2487                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2488                    throws com.liferay.portal.kernel.exception.SystemException {
2489                    return getPersistence()
2490                                       .fetchByG_N_D_Last(groupId, name, description,
2491                            orderByComparator);
2492            }
2493    
2494            /**
2495            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
2496            *
2497            * @param structureId the primary key of the current d d m structure
2498            * @param groupId the group ID
2499            * @param name the name
2500            * @param description the description
2501            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2502            * @return the previous, current, and next d d m structure
2503            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2504            * @throws SystemException if a system exception occurred
2505            */
2506            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_N_D_PrevAndNext(
2507                    long structureId, long groupId, java.lang.String name,
2508                    java.lang.String description,
2509                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2510                    throws com.liferay.portal.kernel.exception.SystemException,
2511                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2512                    return getPersistence()
2513                                       .findByG_N_D_PrevAndNext(structureId, groupId, name,
2514                            description, orderByComparator);
2515            }
2516    
2517            /**
2518            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2519            *
2520            * @param groupId the group ID
2521            * @param name the name
2522            * @param description the description
2523            * @return the matching d d m structures that the user has permission to view
2524            * @throws SystemException if a system exception occurred
2525            */
2526            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
2527                    long groupId, java.lang.String name, java.lang.String description)
2528                    throws com.liferay.portal.kernel.exception.SystemException {
2529                    return getPersistence().filterFindByG_N_D(groupId, name, description);
2530            }
2531    
2532            /**
2533            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2534            *
2535            * <p>
2536            * 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.
2537            * </p>
2538            *
2539            * @param groupId the group ID
2540            * @param name the name
2541            * @param description the description
2542            * @param start the lower bound of the range of d d m structures
2543            * @param end the upper bound of the range of d d m structures (not inclusive)
2544            * @return the range of matching d d m structures that the user has permission to view
2545            * @throws SystemException if a system exception occurred
2546            */
2547            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
2548                    long groupId, java.lang.String name, java.lang.String description,
2549                    int start, int end)
2550                    throws com.liferay.portal.kernel.exception.SystemException {
2551                    return getPersistence()
2552                                       .filterFindByG_N_D(groupId, name, description, start, end);
2553            }
2554    
2555            /**
2556            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and name = &#63; and description = &#63;.
2557            *
2558            * <p>
2559            * 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.
2560            * </p>
2561            *
2562            * @param groupId the group ID
2563            * @param name the name
2564            * @param description the description
2565            * @param start the lower bound of the range of d d m structures
2566            * @param end the upper bound of the range of d d m structures (not inclusive)
2567            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2568            * @return the ordered range of matching d d m structures that the user has permission to view
2569            * @throws SystemException if a system exception occurred
2570            */
2571            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
2572                    long groupId, java.lang.String name, java.lang.String description,
2573                    int start, int end,
2574                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2575                    throws com.liferay.portal.kernel.exception.SystemException {
2576                    return getPersistence()
2577                                       .filterFindByG_N_D(groupId, name, description, start, end,
2578                            orderByComparator);
2579            }
2580    
2581            /**
2582            * Returns the d d m structures before and after the current d d m structure in the ordered set of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2583            *
2584            * @param structureId the primary key of the current d d m structure
2585            * @param groupId the group ID
2586            * @param name the name
2587            * @param description the description
2588            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2589            * @return the previous, current, and next d d m structure
2590            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2591            * @throws SystemException if a system exception occurred
2592            */
2593            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_N_D_PrevAndNext(
2594                    long structureId, long groupId, java.lang.String name,
2595                    java.lang.String description,
2596                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2597                    throws com.liferay.portal.kernel.exception.SystemException,
2598                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2599                    return getPersistence()
2600                                       .filterFindByG_N_D_PrevAndNext(structureId, groupId, name,
2601                            description, orderByComparator);
2602            }
2603    
2604            /**
2605            * Removes all the d d m structures where groupId = &#63; and name = &#63; and description = &#63; from the database.
2606            *
2607            * @param groupId the group ID
2608            * @param name the name
2609            * @param description the description
2610            * @throws SystemException if a system exception occurred
2611            */
2612            public static void removeByG_N_D(long groupId, java.lang.String name,
2613                    java.lang.String description)
2614                    throws com.liferay.portal.kernel.exception.SystemException {
2615                    getPersistence().removeByG_N_D(groupId, name, description);
2616            }
2617    
2618            /**
2619            * Returns the number of d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
2620            *
2621            * @param groupId the group ID
2622            * @param name the name
2623            * @param description the description
2624            * @return the number of matching d d m structures
2625            * @throws SystemException if a system exception occurred
2626            */
2627            public static int countByG_N_D(long groupId, java.lang.String name,
2628                    java.lang.String description)
2629                    throws com.liferay.portal.kernel.exception.SystemException {
2630                    return getPersistence().countByG_N_D(groupId, name, description);
2631            }
2632    
2633            /**
2634            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
2635            *
2636            * @param groupId the group ID
2637            * @param name the name
2638            * @param description the description
2639            * @return the number of matching d d m structures that the user has permission to view
2640            * @throws SystemException if a system exception occurred
2641            */
2642            public static int filterCountByG_N_D(long groupId, java.lang.String name,
2643                    java.lang.String description)
2644                    throws com.liferay.portal.kernel.exception.SystemException {
2645                    return getPersistence().filterCountByG_N_D(groupId, name, description);
2646            }
2647    
2648            /**
2649            * Caches the d d m structure in the entity cache if it is enabled.
2650            *
2651            * @param ddmStructure the d d m structure
2652            */
2653            public static void cacheResult(
2654                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure) {
2655                    getPersistence().cacheResult(ddmStructure);
2656            }
2657    
2658            /**
2659            * Caches the d d m structures in the entity cache if it is enabled.
2660            *
2661            * @param ddmStructures the d d m structures
2662            */
2663            public static void cacheResult(
2664                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures) {
2665                    getPersistence().cacheResult(ddmStructures);
2666            }
2667    
2668            /**
2669            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
2670            *
2671            * @param structureId the primary key for the new d d m structure
2672            * @return the new d d m structure
2673            */
2674            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure create(
2675                    long structureId) {
2676                    return getPersistence().create(structureId);
2677            }
2678    
2679            /**
2680            * Removes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
2681            *
2682            * @param structureId the primary key of the d d m structure
2683            * @return the d d m structure that was removed
2684            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2685            * @throws SystemException if a system exception occurred
2686            */
2687            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure remove(
2688                    long structureId)
2689                    throws com.liferay.portal.kernel.exception.SystemException,
2690                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2691                    return getPersistence().remove(structureId);
2692            }
2693    
2694            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateImpl(
2695                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure)
2696                    throws com.liferay.portal.kernel.exception.SystemException {
2697                    return getPersistence().updateImpl(ddmStructure);
2698            }
2699    
2700            /**
2701            * Returns the d d m structure with the primary key or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchStructureException} if it could not be found.
2702            *
2703            * @param structureId the primary key of the d d m structure
2704            * @return the d d m structure
2705            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
2706            * @throws SystemException if a system exception occurred
2707            */
2708            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByPrimaryKey(
2709                    long structureId)
2710                    throws com.liferay.portal.kernel.exception.SystemException,
2711                            com.liferay.portlet.dynamicdatamapping.NoSuchStructureException {
2712                    return getPersistence().findByPrimaryKey(structureId);
2713            }
2714    
2715            /**
2716            * Returns the d d m structure with the primary key or returns <code>null</code> if it could not be found.
2717            *
2718            * @param structureId the primary key of the d d m structure
2719            * @return the d d m structure, or <code>null</code> if a d d m structure with the primary key could not be found
2720            * @throws SystemException if a system exception occurred
2721            */
2722            public static com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByPrimaryKey(
2723                    long structureId)
2724                    throws com.liferay.portal.kernel.exception.SystemException {
2725                    return getPersistence().fetchByPrimaryKey(structureId);
2726            }
2727    
2728            /**
2729            * Returns all the d d m structures.
2730            *
2731            * @return the d d m structures
2732            * @throws SystemException if a system exception occurred
2733            */
2734            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll()
2735                    throws com.liferay.portal.kernel.exception.SystemException {
2736                    return getPersistence().findAll();
2737            }
2738    
2739            /**
2740            * Returns a range of all the d d m structures.
2741            *
2742            * <p>
2743            * 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.
2744            * </p>
2745            *
2746            * @param start the lower bound of the range of d d m structures
2747            * @param end the upper bound of the range of d d m structures (not inclusive)
2748            * @return the range of d d m structures
2749            * @throws SystemException if a system exception occurred
2750            */
2751            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
2752                    int start, int end)
2753                    throws com.liferay.portal.kernel.exception.SystemException {
2754                    return getPersistence().findAll(start, end);
2755            }
2756    
2757            /**
2758            * Returns an ordered range of all the d d m structures.
2759            *
2760            * <p>
2761            * 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.
2762            * </p>
2763            *
2764            * @param start the lower bound of the range of d d m structures
2765            * @param end the upper bound of the range of d d m structures (not inclusive)
2766            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2767            * @return the ordered range of d d m structures
2768            * @throws SystemException if a system exception occurred
2769            */
2770            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
2771                    int start, int end,
2772                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2773                    throws com.liferay.portal.kernel.exception.SystemException {
2774                    return getPersistence().findAll(start, end, orderByComparator);
2775            }
2776    
2777            /**
2778            * Removes all the d d m structures from the database.
2779            *
2780            * @throws SystemException if a system exception occurred
2781            */
2782            public static void removeAll()
2783                    throws com.liferay.portal.kernel.exception.SystemException {
2784                    getPersistence().removeAll();
2785            }
2786    
2787            /**
2788            * Returns the number of d d m structures.
2789            *
2790            * @return the number of d d m structures
2791            * @throws SystemException if a system exception occurred
2792            */
2793            public static int countAll()
2794                    throws com.liferay.portal.kernel.exception.SystemException {
2795                    return getPersistence().countAll();
2796            }
2797    
2798            /**
2799            * Returns all the document library file entry types associated with the d d m structure.
2800            *
2801            * @param pk the primary key of the d d m structure
2802            * @return the document library file entry types associated with the d d m structure
2803            * @throws SystemException if a system exception occurred
2804            */
2805            public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2806                    long pk) throws com.liferay.portal.kernel.exception.SystemException {
2807                    return getPersistence().getDLFileEntryTypes(pk);
2808            }
2809    
2810            /**
2811            * Returns a range of all the document library file entry types associated with the d d m structure.
2812            *
2813            * <p>
2814            * 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.
2815            * </p>
2816            *
2817            * @param pk the primary key of the d d m structure
2818            * @param start the lower bound of the range of d d m structures
2819            * @param end the upper bound of the range of d d m structures (not inclusive)
2820            * @return the range of document library file entry types associated with the d d m structure
2821            * @throws SystemException if a system exception occurred
2822            */
2823            public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2824                    long pk, int start, int end)
2825                    throws com.liferay.portal.kernel.exception.SystemException {
2826                    return getPersistence().getDLFileEntryTypes(pk, start, end);
2827            }
2828    
2829            /**
2830            * Returns an ordered range of all the document library file entry types associated with the d d m structure.
2831            *
2832            * <p>
2833            * 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.
2834            * </p>
2835            *
2836            * @param pk the primary key of the d d m structure
2837            * @param start the lower bound of the range of d d m structures
2838            * @param end the upper bound of the range of d d m structures (not inclusive)
2839            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2840            * @return the ordered range of document library file entry types associated with the d d m structure
2841            * @throws SystemException if a system exception occurred
2842            */
2843            public static java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2844                    long pk, int start, int end,
2845                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2846                    throws com.liferay.portal.kernel.exception.SystemException {
2847                    return getPersistence()
2848                                       .getDLFileEntryTypes(pk, start, end, orderByComparator);
2849            }
2850    
2851            /**
2852            * Returns the number of document library file entry types associated with the d d m structure.
2853            *
2854            * @param pk the primary key of the d d m structure
2855            * @return the number of document library file entry types associated with the d d m structure
2856            * @throws SystemException if a system exception occurred
2857            */
2858            public static int getDLFileEntryTypesSize(long pk)
2859                    throws com.liferay.portal.kernel.exception.SystemException {
2860                    return getPersistence().getDLFileEntryTypesSize(pk);
2861            }
2862    
2863            /**
2864            * Returns <code>true</code> if the document library file entry type is associated with the d d m structure.
2865            *
2866            * @param pk the primary key of the d d m structure
2867            * @param dlFileEntryTypePK the primary key of the document library file entry type
2868            * @return <code>true</code> if the document library file entry type is associated with the d d m structure; <code>false</code> otherwise
2869            * @throws SystemException if a system exception occurred
2870            */
2871            public static boolean containsDLFileEntryType(long pk,
2872                    long dlFileEntryTypePK)
2873                    throws com.liferay.portal.kernel.exception.SystemException {
2874                    return getPersistence().containsDLFileEntryType(pk, dlFileEntryTypePK);
2875            }
2876    
2877            /**
2878            * Returns <code>true</code> if the d d m structure has any document library file entry types associated with it.
2879            *
2880            * @param pk the primary key of the d d m structure to check for associations with document library file entry types
2881            * @return <code>true</code> if the d d m structure has any document library file entry types associated with it; <code>false</code> otherwise
2882            * @throws SystemException if a system exception occurred
2883            */
2884            public static boolean containsDLFileEntryTypes(long pk)
2885                    throws com.liferay.portal.kernel.exception.SystemException {
2886                    return getPersistence().containsDLFileEntryTypes(pk);
2887            }
2888    
2889            /**
2890            * Adds an association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2891            *
2892            * @param pk the primary key of the d d m structure
2893            * @param dlFileEntryTypePK the primary key of the document library file entry type
2894            * @throws SystemException if a system exception occurred
2895            */
2896            public static void addDLFileEntryType(long pk, long dlFileEntryTypePK)
2897                    throws com.liferay.portal.kernel.exception.SystemException {
2898                    getPersistence().addDLFileEntryType(pk, dlFileEntryTypePK);
2899            }
2900    
2901            /**
2902            * Adds an association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2903            *
2904            * @param pk the primary key of the d d m structure
2905            * @param dlFileEntryType the document library file entry type
2906            * @throws SystemException if a system exception occurred
2907            */
2908            public static void addDLFileEntryType(long pk,
2909                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType)
2910                    throws com.liferay.portal.kernel.exception.SystemException {
2911                    getPersistence().addDLFileEntryType(pk, dlFileEntryType);
2912            }
2913    
2914            /**
2915            * Adds an association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2916            *
2917            * @param pk the primary key of the d d m structure
2918            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2919            * @throws SystemException if a system exception occurred
2920            */
2921            public static void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs)
2922                    throws com.liferay.portal.kernel.exception.SystemException {
2923                    getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypePKs);
2924            }
2925    
2926            /**
2927            * Adds an association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2928            *
2929            * @param pk the primary key of the d d m structure
2930            * @param dlFileEntryTypes the document library file entry types
2931            * @throws SystemException if a system exception occurred
2932            */
2933            public static void addDLFileEntryTypes(long pk,
2934                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes)
2935                    throws com.liferay.portal.kernel.exception.SystemException {
2936                    getPersistence().addDLFileEntryTypes(pk, dlFileEntryTypes);
2937            }
2938    
2939            /**
2940            * Clears all associations between the d d m structure and its document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2941            *
2942            * @param pk the primary key of the d d m structure to clear the associated document library file entry types from
2943            * @throws SystemException if a system exception occurred
2944            */
2945            public static void clearDLFileEntryTypes(long pk)
2946                    throws com.liferay.portal.kernel.exception.SystemException {
2947                    getPersistence().clearDLFileEntryTypes(pk);
2948            }
2949    
2950            /**
2951            * Removes the association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2952            *
2953            * @param pk the primary key of the d d m structure
2954            * @param dlFileEntryTypePK the primary key of the document library file entry type
2955            * @throws SystemException if a system exception occurred
2956            */
2957            public static void removeDLFileEntryType(long pk, long dlFileEntryTypePK)
2958                    throws com.liferay.portal.kernel.exception.SystemException {
2959                    getPersistence().removeDLFileEntryType(pk, dlFileEntryTypePK);
2960            }
2961    
2962            /**
2963            * Removes the association between the d d m structure and the document library file entry type. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2964            *
2965            * @param pk the primary key of the d d m structure
2966            * @param dlFileEntryType the document library file entry type
2967            * @throws SystemException if a system exception occurred
2968            */
2969            public static void removeDLFileEntryType(long pk,
2970                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType)
2971                    throws com.liferay.portal.kernel.exception.SystemException {
2972                    getPersistence().removeDLFileEntryType(pk, dlFileEntryType);
2973            }
2974    
2975            /**
2976            * Removes the association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2977            *
2978            * @param pk the primary key of the d d m structure
2979            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2980            * @throws SystemException if a system exception occurred
2981            */
2982            public static void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs)
2983                    throws com.liferay.portal.kernel.exception.SystemException {
2984                    getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypePKs);
2985            }
2986    
2987            /**
2988            * Removes the association between the d d m structure and the document library file entry types. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2989            *
2990            * @param pk the primary key of the d d m structure
2991            * @param dlFileEntryTypes the document library file entry types
2992            * @throws SystemException if a system exception occurred
2993            */
2994            public static void removeDLFileEntryTypes(long pk,
2995                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes)
2996                    throws com.liferay.portal.kernel.exception.SystemException {
2997                    getPersistence().removeDLFileEntryTypes(pk, dlFileEntryTypes);
2998            }
2999    
3000            /**
3001            * Sets the document library file entry types associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3002            *
3003            * @param pk the primary key of the d d m structure
3004            * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the d d m structure
3005            * @throws SystemException if a system exception occurred
3006            */
3007            public static void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs)
3008                    throws com.liferay.portal.kernel.exception.SystemException {
3009                    getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypePKs);
3010            }
3011    
3012            /**
3013            * Sets the document library file entry types associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
3014            *
3015            * @param pk the primary key of the d d m structure
3016            * @param dlFileEntryTypes the document library file entry types to be associated with the d d m structure
3017            * @throws SystemException if a system exception occurred
3018            */
3019            public static void setDLFileEntryTypes(long pk,
3020                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes)
3021                    throws com.liferay.portal.kernel.exception.SystemException {
3022                    getPersistence().setDLFileEntryTypes(pk, dlFileEntryTypes);
3023            }
3024    
3025            public static DDMStructurePersistence getPersistence() {
3026                    if (_persistence == null) {
3027                            _persistence = (DDMStructurePersistence)PortalBeanLocatorUtil.locate(DDMStructurePersistence.class.getName());
3028    
3029                            ReferenceRegistry.registerReference(DDMStructureUtil.class,
3030                                    "_persistence");
3031                    }
3032    
3033                    return _persistence;
3034            }
3035    
3036            /**
3037             * @deprecated As of 6.2.0
3038             */
3039            public void setPersistence(DDMStructurePersistence persistence) {
3040            }
3041    
3042            private static DDMStructurePersistence _persistence;
3043    }