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