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