001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatamapping.service.persistence;
016    
017    import aQute.bnd.annotation.ProviderType;
018    
019    import com.liferay.portal.service.persistence.BasePersistence;
020    
021    import com.liferay.portlet.dynamicdatamapping.model.DDMStructure;
022    
023    /**
024     * The persistence interface for the d d m structure service.
025     *
026     * <p>
027     * Caching information and settings can be found in <code>portal.properties</code>
028     * </p>
029     *
030     * @author Brian Wing Shun Chan
031     * @see DDMStructurePersistenceImpl
032     * @see DDMStructureUtil
033     * @generated
034     */
035    @ProviderType
036    public interface DDMStructurePersistence extends BasePersistence<DDMStructure> {
037            /*
038             * NOTE FOR DEVELOPERS:
039             *
040             * Never modify or reference this interface directly. Always use {@link DDMStructureUtil} to access the d d m structure persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface.
041             */
042    
043            /**
044            * Returns all the d d m structures where uuid = &#63;.
045            *
046            * @param uuid the uuid
047            * @return the matching d d m structures
048            */
049            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
050                    java.lang.String uuid);
051    
052            /**
053            * Returns a range of all the d d m structures where uuid = &#63;.
054            *
055            * <p>
056            * 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.
057            * </p>
058            *
059            * @param uuid the uuid
060            * @param start the lower bound of the range of d d m structures
061            * @param end the upper bound of the range of d d m structures (not inclusive)
062            * @return the range of matching d d m structures
063            */
064            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
065                    java.lang.String uuid, int start, int end);
066    
067            /**
068            * Returns an ordered range of all the d d m structures where uuid = &#63;.
069            *
070            * <p>
071            * 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.
072            * </p>
073            *
074            * @param uuid the uuid
075            * @param start the lower bound of the range of d d m structures
076            * @param end the upper bound of the range of d d m structures (not inclusive)
077            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
078            * @return the ordered range of matching d d m structures
079            */
080            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid(
081                    java.lang.String uuid, int start, int end,
082                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
083    
084            /**
085            * Returns the first d d m structure in the ordered set where uuid = &#63;.
086            *
087            * @param uuid the uuid
088            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
089            * @return the first matching d d m structure
090            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
091            */
092            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_First(
093                    java.lang.String uuid,
094                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
095                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
096    
097            /**
098            * Returns the first d d m structure in the ordered set where uuid = &#63;.
099            *
100            * @param uuid the uuid
101            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
102            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
103            */
104            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_First(
105                    java.lang.String uuid,
106                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
107    
108            /**
109            * Returns the last d d m structure in the ordered set where uuid = &#63;.
110            *
111            * @param uuid the uuid
112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
113            * @return the last matching d d m structure
114            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
115            */
116            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_Last(
117                    java.lang.String uuid,
118                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
119                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
120    
121            /**
122            * Returns the last d d m structure in the ordered set where uuid = &#63;.
123            *
124            * @param uuid the uuid
125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
126            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
127            */
128            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_Last(
129                    java.lang.String uuid,
130                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
131    
132            /**
133            * Returns the d d m structures before and after the current d d m structure in the ordered set where uuid = &#63;.
134            *
135            * @param structureId the primary key of the current d d m structure
136            * @param uuid the uuid
137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
138            * @return the previous, current, and next d d m structure
139            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
140            */
141            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_PrevAndNext(
142                    long structureId, java.lang.String uuid,
143                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
144                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
145    
146            /**
147            * Removes all the d d m structures where uuid = &#63; from the database.
148            *
149            * @param uuid the uuid
150            */
151            public void removeByUuid(java.lang.String uuid);
152    
153            /**
154            * Returns the number of d d m structures where uuid = &#63;.
155            *
156            * @param uuid the uuid
157            * @return the number of matching d d m structures
158            */
159            public int countByUuid(java.lang.String uuid);
160    
161            /**
162            * 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.
163            *
164            * @param uuid the uuid
165            * @param groupId the group ID
166            * @return the matching d d m structure
167            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
168            */
169            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUUID_G(
170                    java.lang.String uuid, long groupId)
171                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
172    
173            /**
174            * 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.
175            *
176            * @param uuid the uuid
177            * @param groupId the group ID
178            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
179            */
180            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G(
181                    java.lang.String uuid, long groupId);
182    
183            /**
184            * 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.
185            *
186            * @param uuid the uuid
187            * @param groupId the group ID
188            * @param retrieveFromCache whether to use the finder cache
189            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
190            */
191            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUUID_G(
192                    java.lang.String uuid, long groupId, boolean retrieveFromCache);
193    
194            /**
195            * Removes the d d m structure where uuid = &#63; and groupId = &#63; from the database.
196            *
197            * @param uuid the uuid
198            * @param groupId the group ID
199            * @return the d d m structure that was removed
200            */
201            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByUUID_G(
202                    java.lang.String uuid, long groupId)
203                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
204    
205            /**
206            * Returns the number of d d m structures where uuid = &#63; and groupId = &#63;.
207            *
208            * @param uuid the uuid
209            * @param groupId the group ID
210            * @return the number of matching d d m structures
211            */
212            public int countByUUID_G(java.lang.String uuid, long groupId);
213    
214            /**
215            * Returns all the d d m structures where uuid = &#63; and companyId = &#63;.
216            *
217            * @param uuid the uuid
218            * @param companyId the company ID
219            * @return the matching d d m structures
220            */
221            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
222                    java.lang.String uuid, long companyId);
223    
224            /**
225            * Returns a range of all the d d m structures where uuid = &#63; and companyId = &#63;.
226            *
227            * <p>
228            * 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.
229            * </p>
230            *
231            * @param uuid the uuid
232            * @param companyId the company ID
233            * @param start the lower bound of the range of d d m structures
234            * @param end the upper bound of the range of d d m structures (not inclusive)
235            * @return the range of matching d d m structures
236            */
237            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
238                    java.lang.String uuid, long companyId, int start, int end);
239    
240            /**
241            * Returns an ordered range of all the d d m structures where uuid = &#63; and companyId = &#63;.
242            *
243            * <p>
244            * 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.
245            * </p>
246            *
247            * @param uuid the uuid
248            * @param companyId the company ID
249            * @param start the lower bound of the range of d d m structures
250            * @param end the upper bound of the range of d d m structures (not inclusive)
251            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
252            * @return the ordered range of matching d d m structures
253            */
254            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByUuid_C(
255                    java.lang.String uuid, long companyId, int start, int end,
256                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
257    
258            /**
259            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
260            *
261            * @param uuid the uuid
262            * @param companyId the company ID
263            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
264            * @return the first matching d d m structure
265            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
266            */
267            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_First(
268                    java.lang.String uuid, long companyId,
269                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
270                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
271    
272            /**
273            * Returns the first d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
274            *
275            * @param uuid the uuid
276            * @param companyId the company ID
277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
278            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
279            */
280            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_First(
281                    java.lang.String uuid, long companyId,
282                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
283    
284            /**
285            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
286            *
287            * @param uuid the uuid
288            * @param companyId the company ID
289            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
290            * @return the last matching d d m structure
291            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
292            */
293            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByUuid_C_Last(
294                    java.lang.String uuid, long companyId,
295                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
296                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
297    
298            /**
299            * Returns the last d d m structure in the ordered set where uuid = &#63; and companyId = &#63;.
300            *
301            * @param uuid the uuid
302            * @param companyId the company ID
303            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
304            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
305            */
306            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByUuid_C_Last(
307                    java.lang.String uuid, long companyId,
308                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
309    
310            /**
311            * 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;.
312            *
313            * @param structureId the primary key of the current d d m structure
314            * @param uuid the uuid
315            * @param companyId the company ID
316            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
317            * @return the previous, current, and next d d m structure
318            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
319            */
320            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByUuid_C_PrevAndNext(
321                    long structureId, java.lang.String uuid, long companyId,
322                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
323                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
324    
325            /**
326            * Removes all the d d m structures where uuid = &#63; and companyId = &#63; from the database.
327            *
328            * @param uuid the uuid
329            * @param companyId the company ID
330            */
331            public void removeByUuid_C(java.lang.String uuid, long companyId);
332    
333            /**
334            * Returns the number of d d m structures where uuid = &#63; and companyId = &#63;.
335            *
336            * @param uuid the uuid
337            * @param companyId the company ID
338            * @return the number of matching d d m structures
339            */
340            public int countByUuid_C(java.lang.String uuid, long companyId);
341    
342            /**
343            * Returns all the d d m structures where groupId = &#63;.
344            *
345            * @param groupId the group ID
346            * @return the matching d d m structures
347            */
348            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
349                    long groupId);
350    
351            /**
352            * Returns a range of all the d d m structures where groupId = &#63;.
353            *
354            * <p>
355            * 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.
356            * </p>
357            *
358            * @param groupId the group ID
359            * @param start the lower bound of the range of d d m structures
360            * @param end the upper bound of the range of d d m structures (not inclusive)
361            * @return the range of matching d d m structures
362            */
363            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
364                    long groupId, int start, int end);
365    
366            /**
367            * Returns an ordered range of all the d d m structures where groupId = &#63;.
368            *
369            * <p>
370            * 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.
371            * </p>
372            *
373            * @param groupId the group ID
374            * @param start the lower bound of the range of d d m structures
375            * @param end the upper bound of the range of d d m structures (not inclusive)
376            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
377            * @return the ordered range of matching d d m structures
378            */
379            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
380                    long groupId, int start, int end,
381                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
382    
383            /**
384            * Returns the first d d m structure in the ordered set where groupId = &#63;.
385            *
386            * @param groupId the group ID
387            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
388            * @return the first matching d d m structure
389            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
390            */
391            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_First(
392                    long groupId,
393                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
394                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
395    
396            /**
397            * Returns the first d d m structure in the ordered set where groupId = &#63;.
398            *
399            * @param groupId the group ID
400            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
401            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
402            */
403            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_First(
404                    long groupId,
405                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
406    
407            /**
408            * Returns the last d d m structure in the ordered set where groupId = &#63;.
409            *
410            * @param groupId the group ID
411            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
412            * @return the last matching d d m structure
413            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
414            */
415            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByGroupId_Last(
416                    long groupId,
417                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
418                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
419    
420            /**
421            * Returns the last d d m structure in the ordered set where groupId = &#63;.
422            *
423            * @param groupId the group ID
424            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
425            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
426            */
427            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByGroupId_Last(
428                    long groupId,
429                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
430    
431            /**
432            * Returns the d d m structures before and after the current d d m structure in the ordered set where groupId = &#63;.
433            *
434            * @param structureId the primary key of the current d d m structure
435            * @param groupId the group ID
436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
437            * @return the previous, current, and next d d m structure
438            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
439            */
440            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByGroupId_PrevAndNext(
441                    long structureId, long groupId,
442                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
443                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
444    
445            /**
446            * Returns all the d d m structures that the user has permission to view where groupId = &#63;.
447            *
448            * @param groupId the group ID
449            * @return the matching d d m structures that the user has permission to view
450            */
451            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
452                    long groupId);
453    
454            /**
455            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63;.
456            *
457            * <p>
458            * 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.
459            * </p>
460            *
461            * @param groupId the group ID
462            * @param start the lower bound of the range of d d m structures
463            * @param end the upper bound of the range of d d m structures (not inclusive)
464            * @return the range of matching d d m structures that the user has permission to view
465            */
466            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
467                    long groupId, int start, int end);
468    
469            /**
470            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63;.
471            *
472            * <p>
473            * 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.
474            * </p>
475            *
476            * @param groupId the group ID
477            * @param start the lower bound of the range of d d m structures
478            * @param end the upper bound of the range of d d m structures (not inclusive)
479            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
480            * @return the ordered range of matching d d m structures that the user has permission to view
481            */
482            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
483                    long groupId, int start, int end,
484                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
485    
486            /**
487            * 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;.
488            *
489            * @param structureId the primary key of the current d d m structure
490            * @param groupId the group ID
491            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
492            * @return the previous, current, and next d d m structure
493            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
494            */
495            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByGroupId_PrevAndNext(
496                    long structureId, long groupId,
497                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
498                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
499    
500            /**
501            * Returns all the d d m structures that the user has permission to view where groupId = any &#63;.
502            *
503            * @param groupIds the group IDs
504            * @return the matching d d m structures that the user has permission to view
505            */
506            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
507                    long[] groupIds);
508    
509            /**
510            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63;.
511            *
512            * <p>
513            * 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.
514            * </p>
515            *
516            * @param groupIds the group IDs
517            * @param start the lower bound of the range of d d m structures
518            * @param end the upper bound of the range of d d m structures (not inclusive)
519            * @return the range of matching d d m structures that the user has permission to view
520            */
521            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
522                    long[] groupIds, int start, int end);
523    
524            /**
525            * Returns an ordered range of all the d d m structures that the user has permission to view where groupId = any &#63;.
526            *
527            * <p>
528            * 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.
529            * </p>
530            *
531            * @param groupIds the group IDs
532            * @param start the lower bound of the range of d d m structures
533            * @param end the upper bound of the range of d d m structures (not inclusive)
534            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
535            * @return the ordered range of matching d d m structures that the user has permission to view
536            */
537            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByGroupId(
538                    long[] groupIds, int start, int end,
539                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
540    
541            /**
542            * Returns all the d d m structures where groupId = any &#63;.
543            *
544            * <p>
545            * 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.
546            * </p>
547            *
548            * @param groupIds the group IDs
549            * @return the matching d d m structures
550            */
551            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
552                    long[] groupIds);
553    
554            /**
555            * Returns a range of all the d d m structures where groupId = any &#63;.
556            *
557            * <p>
558            * 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.
559            * </p>
560            *
561            * @param groupIds the group IDs
562            * @param start the lower bound of the range of d d m structures
563            * @param end the upper bound of the range of d d m structures (not inclusive)
564            * @return the range of matching d d m structures
565            */
566            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
567                    long[] groupIds, int start, int end);
568    
569            /**
570            * Returns an ordered range of all the d d m structures where groupId = any &#63;.
571            *
572            * <p>
573            * 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.
574            * </p>
575            *
576            * @param groupIds the group IDs
577            * @param start the lower bound of the range of d d m structures
578            * @param end the upper bound of the range of d d m structures (not inclusive)
579            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
580            * @return the ordered range of matching d d m structures
581            */
582            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByGroupId(
583                    long[] groupIds, int start, int end,
584                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
585    
586            /**
587            * Removes all the d d m structures where groupId = &#63; from the database.
588            *
589            * @param groupId the group ID
590            */
591            public void removeByGroupId(long groupId);
592    
593            /**
594            * Returns the number of d d m structures where groupId = &#63;.
595            *
596            * @param groupId the group ID
597            * @return the number of matching d d m structures
598            */
599            public int countByGroupId(long groupId);
600    
601            /**
602            * Returns the number of d d m structures where groupId = any &#63;.
603            *
604            * @param groupIds the group IDs
605            * @return the number of matching d d m structures
606            */
607            public int countByGroupId(long[] groupIds);
608    
609            /**
610            * Returns the number of d d m structures that the user has permission to view where groupId = &#63;.
611            *
612            * @param groupId the group ID
613            * @return the number of matching d d m structures that the user has permission to view
614            */
615            public int filterCountByGroupId(long groupId);
616    
617            /**
618            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63;.
619            *
620            * @param groupIds the group IDs
621            * @return the number of matching d d m structures that the user has permission to view
622            */
623            public int filterCountByGroupId(long[] groupIds);
624    
625            /**
626            * Returns all the d d m structures where parentStructureId = &#63;.
627            *
628            * @param parentStructureId the parent structure ID
629            * @return the matching d d m structures
630            */
631            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByParentStructureId(
632                    long parentStructureId);
633    
634            /**
635            * Returns a range of all the d d m structures where parentStructureId = &#63;.
636            *
637            * <p>
638            * 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.
639            * </p>
640            *
641            * @param parentStructureId the parent structure ID
642            * @param start the lower bound of the range of d d m structures
643            * @param end the upper bound of the range of d d m structures (not inclusive)
644            * @return the range of matching d d m structures
645            */
646            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByParentStructureId(
647                    long parentStructureId, int start, int end);
648    
649            /**
650            * Returns an ordered range of all the d d m structures where parentStructureId = &#63;.
651            *
652            * <p>
653            * 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.
654            * </p>
655            *
656            * @param parentStructureId the parent structure ID
657            * @param start the lower bound of the range of d d m structures
658            * @param end the upper bound of the range of d d m structures (not inclusive)
659            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
660            * @return the ordered range of matching d d m structures
661            */
662            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByParentStructureId(
663                    long parentStructureId, int start, int end,
664                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
665    
666            /**
667            * Returns the first d d m structure in the ordered set where parentStructureId = &#63;.
668            *
669            * @param parentStructureId the parent structure ID
670            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
671            * @return the first matching d d m structure
672            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
673            */
674            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByParentStructureId_First(
675                    long parentStructureId,
676                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
677                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
678    
679            /**
680            * Returns the first d d m structure in the ordered set where parentStructureId = &#63;.
681            *
682            * @param parentStructureId the parent structure ID
683            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
684            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
685            */
686            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByParentStructureId_First(
687                    long parentStructureId,
688                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
689    
690            /**
691            * Returns the last d d m structure in the ordered set where parentStructureId = &#63;.
692            *
693            * @param parentStructureId the parent structure ID
694            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
695            * @return the last matching d d m structure
696            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
697            */
698            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByParentStructureId_Last(
699                    long parentStructureId,
700                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
701                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
702    
703            /**
704            * Returns the last d d m structure in the ordered set where parentStructureId = &#63;.
705            *
706            * @param parentStructureId the parent structure ID
707            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
708            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
709            */
710            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByParentStructureId_Last(
711                    long parentStructureId,
712                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
713    
714            /**
715            * Returns the d d m structures before and after the current d d m structure in the ordered set where parentStructureId = &#63;.
716            *
717            * @param structureId the primary key of the current d d m structure
718            * @param parentStructureId the parent structure ID
719            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
720            * @return the previous, current, and next d d m structure
721            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
722            */
723            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByParentStructureId_PrevAndNext(
724                    long structureId, long parentStructureId,
725                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
726                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
727    
728            /**
729            * Removes all the d d m structures where parentStructureId = &#63; from the database.
730            *
731            * @param parentStructureId the parent structure ID
732            */
733            public void removeByParentStructureId(long parentStructureId);
734    
735            /**
736            * Returns the number of d d m structures where parentStructureId = &#63;.
737            *
738            * @param parentStructureId the parent structure ID
739            * @return the number of matching d d m structures
740            */
741            public int countByParentStructureId(long parentStructureId);
742    
743            /**
744            * Returns all the d d m structures where classNameId = &#63;.
745            *
746            * @param classNameId the class name ID
747            * @return the matching d d m structures
748            */
749            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
750                    long classNameId);
751    
752            /**
753            * Returns a range of all the d d m structures where classNameId = &#63;.
754            *
755            * <p>
756            * 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.
757            * </p>
758            *
759            * @param classNameId the class name ID
760            * @param start the lower bound of the range of d d m structures
761            * @param end the upper bound of the range of d d m structures (not inclusive)
762            * @return the range of matching d d m structures
763            */
764            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
765                    long classNameId, int start, int end);
766    
767            /**
768            * Returns an ordered range of all the d d m structures where classNameId = &#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 classNameId the class name ID
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
779            */
780            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByClassNameId(
781                    long classNameId, int start, int end,
782                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
783    
784            /**
785            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
786            *
787            * @param classNameId the class name ID
788            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
789            * @return the first matching d d m structure
790            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
791            */
792            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_First(
793                    long classNameId,
794                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
795                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
796    
797            /**
798            * Returns the first d d m structure in the ordered set where classNameId = &#63;.
799            *
800            * @param classNameId the class name ID
801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
802            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
803            */
804            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_First(
805                    long classNameId,
806                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
807    
808            /**
809            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
810            *
811            * @param classNameId the class name ID
812            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
813            * @return the last matching d d m structure
814            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
815            */
816            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByClassNameId_Last(
817                    long classNameId,
818                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
819                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
820    
821            /**
822            * Returns the last d d m structure in the ordered set where classNameId = &#63;.
823            *
824            * @param classNameId the class name ID
825            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
826            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
827            */
828            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByClassNameId_Last(
829                    long classNameId,
830                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
831    
832            /**
833            * Returns the d d m structures before and after the current d d m structure in the ordered set where classNameId = &#63;.
834            *
835            * @param structureId the primary key of the current d d m structure
836            * @param classNameId the class name ID
837            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
838            * @return the previous, current, and next d d m structure
839            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
840            */
841            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByClassNameId_PrevAndNext(
842                    long structureId, long classNameId,
843                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
844                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
845    
846            /**
847            * Removes all the d d m structures where classNameId = &#63; from the database.
848            *
849            * @param classNameId the class name ID
850            */
851            public void removeByClassNameId(long classNameId);
852    
853            /**
854            * Returns the number of d d m structures where classNameId = &#63;.
855            *
856            * @param classNameId the class name ID
857            * @return the number of matching d d m structures
858            */
859            public int countByClassNameId(long classNameId);
860    
861            /**
862            * Returns all the d d m structures where structureKey = &#63;.
863            *
864            * @param structureKey the structure key
865            * @return the matching d d m structures
866            */
867            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
868                    java.lang.String structureKey);
869    
870            /**
871            * Returns a range of all the d d m structures where structureKey = &#63;.
872            *
873            * <p>
874            * 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.
875            * </p>
876            *
877            * @param structureKey the structure key
878            * @param start the lower bound of the range of d d m structures
879            * @param end the upper bound of the range of d d m structures (not inclusive)
880            * @return the range of matching d d m structures
881            */
882            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
883                    java.lang.String structureKey, int start, int end);
884    
885            /**
886            * Returns an ordered range of all the d d m structures where structureKey = &#63;.
887            *
888            * <p>
889            * 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.
890            * </p>
891            *
892            * @param structureKey the structure key
893            * @param start the lower bound of the range of d d m structures
894            * @param end the upper bound of the range of d d m structures (not inclusive)
895            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
896            * @return the ordered range of matching d d m structures
897            */
898            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByStructureKey(
899                    java.lang.String structureKey, int start, int end,
900                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
901    
902            /**
903            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
904            *
905            * @param structureKey the structure key
906            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
907            * @return the first matching d d m structure
908            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
909            */
910            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_First(
911                    java.lang.String structureKey,
912                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
913                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
914    
915            /**
916            * Returns the first d d m structure in the ordered set where structureKey = &#63;.
917            *
918            * @param structureKey the structure key
919            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
920            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
921            */
922            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_First(
923                    java.lang.String structureKey,
924                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
925    
926            /**
927            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
928            *
929            * @param structureKey the structure key
930            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
931            * @return the last matching d d m structure
932            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
933            */
934            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByStructureKey_Last(
935                    java.lang.String structureKey,
936                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
937                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
938    
939            /**
940            * Returns the last d d m structure in the ordered set where structureKey = &#63;.
941            *
942            * @param structureKey the structure key
943            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
944            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
945            */
946            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByStructureKey_Last(
947                    java.lang.String structureKey,
948                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
949    
950            /**
951            * Returns the d d m structures before and after the current d d m structure in the ordered set where structureKey = &#63;.
952            *
953            * @param structureId the primary key of the current d d m structure
954            * @param structureKey the structure key
955            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
956            * @return the previous, current, and next d d m structure
957            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
958            */
959            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByStructureKey_PrevAndNext(
960                    long structureId, java.lang.String structureKey,
961                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
962                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
963    
964            /**
965            * Removes all the d d m structures where structureKey = &#63; from the database.
966            *
967            * @param structureKey the structure key
968            */
969            public void removeByStructureKey(java.lang.String structureKey);
970    
971            /**
972            * Returns the number of d d m structures where structureKey = &#63;.
973            *
974            * @param structureKey the structure key
975            * @return the number of matching d d m structures
976            */
977            public int countByStructureKey(java.lang.String structureKey);
978    
979            /**
980            * Returns all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
981            *
982            * @param groupId the group ID
983            * @param parentStructureId the parent structure ID
984            * @return the matching d d m structures
985            */
986            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P(
987                    long groupId, long parentStructureId);
988    
989            /**
990            * Returns a range of all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
991            *
992            * <p>
993            * 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.
994            * </p>
995            *
996            * @param groupId the group ID
997            * @param parentStructureId the parent structure ID
998            * @param start the lower bound of the range of d d m structures
999            * @param end the upper bound of the range of d d m structures (not inclusive)
1000            * @return the range of matching d d m structures
1001            */
1002            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P(
1003                    long groupId, long parentStructureId, int start, int end);
1004    
1005            /**
1006            * Returns an ordered range of all the d d m structures where groupId = &#63; and parentStructureId = &#63;.
1007            *
1008            * <p>
1009            * 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.
1010            * </p>
1011            *
1012            * @param groupId the group ID
1013            * @param parentStructureId the parent structure ID
1014            * @param start the lower bound of the range of d d m structures
1015            * @param end the upper bound of the range of d d m structures (not inclusive)
1016            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1017            * @return the ordered range of matching d d m structures
1018            */
1019            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_P(
1020                    long groupId, long parentStructureId, int start, int end,
1021                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1022    
1023            /**
1024            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1025            *
1026            * @param groupId the group ID
1027            * @param parentStructureId the parent structure ID
1028            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1029            * @return the first matching d d m structure
1030            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1031            */
1032            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_First(
1033                    long groupId, long parentStructureId,
1034                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1035                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1036    
1037            /**
1038            * Returns the first d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1039            *
1040            * @param groupId the group ID
1041            * @param parentStructureId the parent structure ID
1042            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1043            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1044            */
1045            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_First(
1046                    long groupId, long parentStructureId,
1047                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1048    
1049            /**
1050            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1051            *
1052            * @param groupId the group ID
1053            * @param parentStructureId the parent structure ID
1054            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1055            * @return the last matching d d m structure
1056            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1057            */
1058            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_P_Last(
1059                    long groupId, long parentStructureId,
1060                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1061                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1062    
1063            /**
1064            * Returns the last d d m structure in the ordered set where groupId = &#63; and parentStructureId = &#63;.
1065            *
1066            * @param groupId the group ID
1067            * @param parentStructureId the parent structure ID
1068            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1069            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1070            */
1071            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_P_Last(
1072                    long groupId, long parentStructureId,
1073                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1074    
1075            /**
1076            * 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;.
1077            *
1078            * @param structureId the primary key of the current d d m structure
1079            * @param groupId the group ID
1080            * @param parentStructureId the parent structure ID
1081            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1082            * @return the previous, current, and next d d m structure
1083            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1084            */
1085            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_P_PrevAndNext(
1086                    long structureId, long groupId, long parentStructureId,
1087                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1088                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1089    
1090            /**
1091            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1092            *
1093            * @param groupId the group ID
1094            * @param parentStructureId the parent structure ID
1095            * @return the matching d d m structures that the user has permission to view
1096            */
1097            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1098                    long groupId, long parentStructureId);
1099    
1100            /**
1101            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1102            *
1103            * <p>
1104            * 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.
1105            * </p>
1106            *
1107            * @param groupId the group ID
1108            * @param parentStructureId the parent structure ID
1109            * @param start the lower bound of the range of d d m structures
1110            * @param end the upper bound of the range of d d m structures (not inclusive)
1111            * @return the range of matching d d m structures that the user has permission to view
1112            */
1113            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1114                    long groupId, long parentStructureId, int start, int end);
1115    
1116            /**
1117            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and parentStructureId = &#63;.
1118            *
1119            * <p>
1120            * 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.
1121            * </p>
1122            *
1123            * @param groupId the group ID
1124            * @param parentStructureId the parent structure ID
1125            * @param start the lower bound of the range of d d m structures
1126            * @param end the upper bound of the range of d d m structures (not inclusive)
1127            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1128            * @return the ordered range of matching d d m structures that the user has permission to view
1129            */
1130            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_P(
1131                    long groupId, long parentStructureId, int start, int end,
1132                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1133    
1134            /**
1135            * 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;.
1136            *
1137            * @param structureId the primary key of the current d d m structure
1138            * @param groupId the group ID
1139            * @param parentStructureId the parent structure ID
1140            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1141            * @return the previous, current, and next d d m structure
1142            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1143            */
1144            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_P_PrevAndNext(
1145                    long structureId, long groupId, long parentStructureId,
1146                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1147                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1148    
1149            /**
1150            * Removes all the d d m structures where groupId = &#63; and parentStructureId = &#63; from the database.
1151            *
1152            * @param groupId the group ID
1153            * @param parentStructureId the parent structure ID
1154            */
1155            public void removeByG_P(long groupId, long parentStructureId);
1156    
1157            /**
1158            * Returns the number of d d m structures where groupId = &#63; and parentStructureId = &#63;.
1159            *
1160            * @param groupId the group ID
1161            * @param parentStructureId the parent structure ID
1162            * @return the number of matching d d m structures
1163            */
1164            public int countByG_P(long groupId, long parentStructureId);
1165    
1166            /**
1167            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and parentStructureId = &#63;.
1168            *
1169            * @param groupId the group ID
1170            * @param parentStructureId the parent structure ID
1171            * @return the number of matching d d m structures that the user has permission to view
1172            */
1173            public int filterCountByG_P(long groupId, long parentStructureId);
1174    
1175            /**
1176            * Returns all the d d m structures where groupId = &#63; and classNameId = &#63;.
1177            *
1178            * @param groupId the group ID
1179            * @param classNameId the class name ID
1180            * @return the matching d d m structures
1181            */
1182            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1183                    long groupId, long classNameId);
1184    
1185            /**
1186            * Returns a range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1187            *
1188            * <p>
1189            * 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.
1190            * </p>
1191            *
1192            * @param groupId the group ID
1193            * @param classNameId the class name ID
1194            * @param start the lower bound of the range of d d m structures
1195            * @param end the upper bound of the range of d d m structures (not inclusive)
1196            * @return the range of matching d d m structures
1197            */
1198            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1199                    long groupId, long classNameId, int start, int end);
1200    
1201            /**
1202            * Returns an ordered range of all the d d m structures where groupId = &#63; and classNameId = &#63;.
1203            *
1204            * <p>
1205            * 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.
1206            * </p>
1207            *
1208            * @param groupId the group ID
1209            * @param classNameId the class name ID
1210            * @param start the lower bound of the range of d d m structures
1211            * @param end the upper bound of the range of d d m structures (not inclusive)
1212            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1213            * @return the ordered range of matching d d m structures
1214            */
1215            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1216                    long groupId, long classNameId, int start, int end,
1217                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1218    
1219            /**
1220            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1221            *
1222            * @param groupId the group ID
1223            * @param classNameId the class name ID
1224            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1225            * @return the first matching d d m structure
1226            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1227            */
1228            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_First(
1229                    long groupId, long classNameId,
1230                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1231                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1232    
1233            /**
1234            * Returns the first d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1235            *
1236            * @param groupId the group ID
1237            * @param classNameId the class name ID
1238            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1239            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1240            */
1241            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_First(
1242                    long groupId, long classNameId,
1243                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1244    
1245            /**
1246            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1247            *
1248            * @param groupId the group ID
1249            * @param classNameId the class name ID
1250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1251            * @return the last matching d d m structure
1252            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1253            */
1254            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_Last(
1255                    long groupId, long classNameId,
1256                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1257                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1258    
1259            /**
1260            * Returns the last d d m structure in the ordered set where groupId = &#63; and classNameId = &#63;.
1261            *
1262            * @param groupId the group ID
1263            * @param classNameId the class name ID
1264            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1265            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1266            */
1267            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_Last(
1268                    long groupId, long classNameId,
1269                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1270    
1271            /**
1272            * 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;.
1273            *
1274            * @param structureId the primary key of the current d d m structure
1275            * @param groupId the group ID
1276            * @param classNameId the class name ID
1277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1278            * @return the previous, current, and next d d m structure
1279            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1280            */
1281            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_C_PrevAndNext(
1282                    long structureId, long groupId, long classNameId,
1283                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1284                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1285    
1286            /**
1287            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1288            *
1289            * @param groupId the group ID
1290            * @param classNameId the class name ID
1291            * @return the matching d d m structures that the user has permission to view
1292            */
1293            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1294                    long groupId, long classNameId);
1295    
1296            /**
1297            * Returns a range of all the d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1298            *
1299            * <p>
1300            * 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.
1301            * </p>
1302            *
1303            * @param groupId the group ID
1304            * @param classNameId the class name ID
1305            * @param start the lower bound of the range of d d m structures
1306            * @param end the upper bound of the range of d d m structures (not inclusive)
1307            * @return the range of matching d d m structures that the user has permission to view
1308            */
1309            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1310                    long groupId, long classNameId, int start, int end);
1311    
1312            /**
1313            * Returns an ordered range of all the d d m structures that the user has permissions to view where groupId = &#63; and classNameId = &#63;.
1314            *
1315            * <p>
1316            * 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.
1317            * </p>
1318            *
1319            * @param groupId the group ID
1320            * @param classNameId the class name ID
1321            * @param start the lower bound of the range of d d m structures
1322            * @param end the upper bound of the range of d d m structures (not inclusive)
1323            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1324            * @return the ordered range of matching d d m structures that the user has permission to view
1325            */
1326            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1327                    long groupId, long classNameId, int start, int end,
1328                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1329    
1330            /**
1331            * 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;.
1332            *
1333            * @param structureId the primary key of the current d d m structure
1334            * @param groupId the group ID
1335            * @param classNameId the class name ID
1336            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1337            * @return the previous, current, and next d d m structure
1338            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1339            */
1340            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_C_PrevAndNext(
1341                    long structureId, long groupId, long classNameId,
1342                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1343                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1344    
1345            /**
1346            * Returns all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1347            *
1348            * @param groupIds the group IDs
1349            * @param classNameId the class name ID
1350            * @return the matching d d m structures that the user has permission to view
1351            */
1352            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1353                    long[] groupIds, long classNameId);
1354    
1355            /**
1356            * Returns a range of all the d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1357            *
1358            * <p>
1359            * 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.
1360            * </p>
1361            *
1362            * @param groupIds the group IDs
1363            * @param classNameId the class name ID
1364            * @param start the lower bound of the range of d d m structures
1365            * @param end the upper bound of the range of d d m structures (not inclusive)
1366            * @return the range of matching d d m structures that the user has permission to view
1367            */
1368            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1369                    long[] groupIds, long classNameId, int start, int end);
1370    
1371            /**
1372            * 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;.
1373            *
1374            * <p>
1375            * 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.
1376            * </p>
1377            *
1378            * @param groupIds the group IDs
1379            * @param classNameId the class name ID
1380            * @param start the lower bound of the range of d d m structures
1381            * @param end the upper bound of the range of d d m structures (not inclusive)
1382            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1383            * @return the ordered range of matching d d m structures that the user has permission to view
1384            */
1385            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_C(
1386                    long[] groupIds, long classNameId, int start, int end,
1387                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1388    
1389            /**
1390            * Returns all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1391            *
1392            * <p>
1393            * 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.
1394            * </p>
1395            *
1396            * @param groupIds the group IDs
1397            * @param classNameId the class name ID
1398            * @return the matching d d m structures
1399            */
1400            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1401                    long[] groupIds, long classNameId);
1402    
1403            /**
1404            * Returns a range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1405            *
1406            * <p>
1407            * 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.
1408            * </p>
1409            *
1410            * @param groupIds the group IDs
1411            * @param classNameId the class name ID
1412            * @param start the lower bound of the range of d d m structures
1413            * @param end the upper bound of the range of d d m structures (not inclusive)
1414            * @return the range of matching d d m structures
1415            */
1416            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1417                    long[] groupIds, long classNameId, int start, int end);
1418    
1419            /**
1420            * Returns an ordered range of all the d d m structures where groupId = any &#63; and classNameId = &#63;.
1421            *
1422            * <p>
1423            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.DDMStructureModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order.
1424            * </p>
1425            *
1426            * @param groupIds the group IDs
1427            * @param classNameId the class name ID
1428            * @param start the lower bound of the range of d d m structures
1429            * @param end the upper bound of the range of d d m structures (not inclusive)
1430            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1431            * @return the ordered range of matching d d m structures
1432            */
1433            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_C(
1434                    long[] groupIds, long classNameId, int start, int end,
1435                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1436    
1437            /**
1438            * Removes all the d d m structures where groupId = &#63; and classNameId = &#63; from the database.
1439            *
1440            * @param groupId the group ID
1441            * @param classNameId the class name ID
1442            */
1443            public void removeByG_C(long groupId, long classNameId);
1444    
1445            /**
1446            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63;.
1447            *
1448            * @param groupId the group ID
1449            * @param classNameId the class name ID
1450            * @return the number of matching d d m structures
1451            */
1452            public int countByG_C(long groupId, long classNameId);
1453    
1454            /**
1455            * Returns the number of d d m structures where groupId = any &#63; and classNameId = &#63;.
1456            *
1457            * @param groupIds the group IDs
1458            * @param classNameId the class name ID
1459            * @return the number of matching d d m structures
1460            */
1461            public int countByG_C(long[] groupIds, long classNameId);
1462    
1463            /**
1464            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and classNameId = &#63;.
1465            *
1466            * @param groupId the group ID
1467            * @param classNameId the class name ID
1468            * @return the number of matching d d m structures that the user has permission to view
1469            */
1470            public int filterCountByG_C(long groupId, long classNameId);
1471    
1472            /**
1473            * Returns the number of d d m structures that the user has permission to view where groupId = any &#63; and classNameId = &#63;.
1474            *
1475            * @param groupIds the group IDs
1476            * @param classNameId the class name ID
1477            * @return the number of matching d d m structures that the user has permission to view
1478            */
1479            public int filterCountByG_C(long[] groupIds, long classNameId);
1480    
1481            /**
1482            * Returns all the d d m structures where companyId = &#63; and classNameId = &#63;.
1483            *
1484            * @param companyId the company ID
1485            * @param classNameId the class name ID
1486            * @return the matching d d m structures
1487            */
1488            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1489                    long companyId, long classNameId);
1490    
1491            /**
1492            * Returns a range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1493            *
1494            * <p>
1495            * 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.
1496            * </p>
1497            *
1498            * @param companyId the company ID
1499            * @param classNameId the class name ID
1500            * @param start the lower bound of the range of d d m structures
1501            * @param end the upper bound of the range of d d m structures (not inclusive)
1502            * @return the range of matching d d m structures
1503            */
1504            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1505                    long companyId, long classNameId, int start, int end);
1506    
1507            /**
1508            * Returns an ordered range of all the d d m structures where companyId = &#63; and classNameId = &#63;.
1509            *
1510            * <p>
1511            * 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.
1512            * </p>
1513            *
1514            * @param companyId the company ID
1515            * @param classNameId the class name ID
1516            * @param start the lower bound of the range of d d m structures
1517            * @param end the upper bound of the range of d d m structures (not inclusive)
1518            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1519            * @return the ordered range of matching d d m structures
1520            */
1521            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByC_C(
1522                    long companyId, long classNameId, int start, int end,
1523                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1524    
1525            /**
1526            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1527            *
1528            * @param companyId the company ID
1529            * @param classNameId the class name ID
1530            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1531            * @return the first matching d d m structure
1532            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1533            */
1534            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_First(
1535                    long companyId, long classNameId,
1536                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1537                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1538    
1539            /**
1540            * Returns the first d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1541            *
1542            * @param companyId the company ID
1543            * @param classNameId the class name ID
1544            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1545            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1546            */
1547            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_First(
1548                    long companyId, long classNameId,
1549                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1550    
1551            /**
1552            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1553            *
1554            * @param companyId the company ID
1555            * @param classNameId the class name ID
1556            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1557            * @return the last matching d d m structure
1558            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1559            */
1560            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByC_C_Last(
1561                    long companyId, long classNameId,
1562                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1563                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1564    
1565            /**
1566            * Returns the last d d m structure in the ordered set where companyId = &#63; and classNameId = &#63;.
1567            *
1568            * @param companyId the company ID
1569            * @param classNameId the class name ID
1570            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1571            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1572            */
1573            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByC_C_Last(
1574                    long companyId, long classNameId,
1575                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1576    
1577            /**
1578            * 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;.
1579            *
1580            * @param structureId the primary key of the current d d m structure
1581            * @param companyId the company ID
1582            * @param classNameId the class name ID
1583            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1584            * @return the previous, current, and next d d m structure
1585            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1586            */
1587            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByC_C_PrevAndNext(
1588                    long structureId, long companyId, long classNameId,
1589                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1590                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1591    
1592            /**
1593            * Removes all the d d m structures where companyId = &#63; and classNameId = &#63; from the database.
1594            *
1595            * @param companyId the company ID
1596            * @param classNameId the class name ID
1597            */
1598            public void removeByC_C(long companyId, long classNameId);
1599    
1600            /**
1601            * Returns the number of d d m structures where companyId = &#63; and classNameId = &#63;.
1602            *
1603            * @param companyId the company ID
1604            * @param classNameId the class name ID
1605            * @return the number of matching d d m structures
1606            */
1607            public int countByC_C(long companyId, long classNameId);
1608    
1609            /**
1610            * 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.
1611            *
1612            * @param groupId the group ID
1613            * @param classNameId the class name ID
1614            * @param structureKey the structure key
1615            * @return the matching d d m structure
1616            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1617            */
1618            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_C_S(
1619                    long groupId, long classNameId, java.lang.String structureKey)
1620                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1621    
1622            /**
1623            * 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.
1624            *
1625            * @param groupId the group ID
1626            * @param classNameId the class name ID
1627            * @param structureKey the structure key
1628            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1629            */
1630            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
1631                    long groupId, long classNameId, java.lang.String structureKey);
1632    
1633            /**
1634            * 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.
1635            *
1636            * @param groupId the group ID
1637            * @param classNameId the class name ID
1638            * @param structureKey the structure key
1639            * @param retrieveFromCache whether to use the finder cache
1640            * @return the matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1641            */
1642            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_C_S(
1643                    long groupId, long classNameId, java.lang.String structureKey,
1644                    boolean retrieveFromCache);
1645    
1646            /**
1647            * Removes the d d m structure where groupId = &#63; and classNameId = &#63; and structureKey = &#63; from the database.
1648            *
1649            * @param groupId the group ID
1650            * @param classNameId the class name ID
1651            * @param structureKey the structure key
1652            * @return the d d m structure that was removed
1653            */
1654            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure removeByG_C_S(
1655                    long groupId, long classNameId, java.lang.String structureKey)
1656                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1657    
1658            /**
1659            * Returns the number of d d m structures where groupId = &#63; and classNameId = &#63; and structureKey = &#63;.
1660            *
1661            * @param groupId the group ID
1662            * @param classNameId the class name ID
1663            * @param structureKey the structure key
1664            * @return the number of matching d d m structures
1665            */
1666            public int countByG_C_S(long groupId, long classNameId,
1667                    java.lang.String structureKey);
1668    
1669            /**
1670            * Returns all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1671            *
1672            * @param groupId the group ID
1673            * @param name the name
1674            * @param description the description
1675            * @return the matching d d m structures
1676            */
1677            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
1678                    long groupId, java.lang.String name, java.lang.String description);
1679    
1680            /**
1681            * Returns a range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1682            *
1683            * <p>
1684            * 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.
1685            * </p>
1686            *
1687            * @param groupId the group ID
1688            * @param name the name
1689            * @param description the description
1690            * @param start the lower bound of the range of d d m structures
1691            * @param end the upper bound of the range of d d m structures (not inclusive)
1692            * @return the range of matching d d m structures
1693            */
1694            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
1695                    long groupId, java.lang.String name, java.lang.String description,
1696                    int start, int end);
1697    
1698            /**
1699            * Returns an ordered range of all the d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1700            *
1701            * <p>
1702            * 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.
1703            * </p>
1704            *
1705            * @param groupId the group ID
1706            * @param name the name
1707            * @param description the description
1708            * @param start the lower bound of the range of d d m structures
1709            * @param end the upper bound of the range of d d m structures (not inclusive)
1710            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1711            * @return the ordered range of matching d d m structures
1712            */
1713            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findByG_N_D(
1714                    long groupId, java.lang.String name, java.lang.String description,
1715                    int start, int end,
1716                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1717    
1718            /**
1719            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1720            *
1721            * @param groupId the group ID
1722            * @param name the name
1723            * @param description the description
1724            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1725            * @return the first matching d d m structure
1726            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1727            */
1728            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_First(
1729                    long groupId, java.lang.String name, java.lang.String description,
1730                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1731                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1732    
1733            /**
1734            * Returns the first d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1735            *
1736            * @param groupId the group ID
1737            * @param name the name
1738            * @param description the description
1739            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1740            * @return the first matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1741            */
1742            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_First(
1743                    long groupId, java.lang.String name, java.lang.String description,
1744                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1745    
1746            /**
1747            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1748            *
1749            * @param groupId the group ID
1750            * @param name the name
1751            * @param description the description
1752            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1753            * @return the last matching d d m structure
1754            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a matching d d m structure could not be found
1755            */
1756            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByG_N_D_Last(
1757                    long groupId, java.lang.String name, java.lang.String description,
1758                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1759                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1760    
1761            /**
1762            * Returns the last d d m structure in the ordered set where groupId = &#63; and name = &#63; and description = &#63;.
1763            *
1764            * @param groupId the group ID
1765            * @param name the name
1766            * @param description the description
1767            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1768            * @return the last matching d d m structure, or <code>null</code> if a matching d d m structure could not be found
1769            */
1770            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByG_N_D_Last(
1771                    long groupId, java.lang.String name, java.lang.String description,
1772                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1773    
1774            /**
1775            * 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;.
1776            *
1777            * @param structureId the primary key of the current d d m structure
1778            * @param groupId the group ID
1779            * @param name the name
1780            * @param description the description
1781            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1782            * @return the previous, current, and next d d m structure
1783            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1784            */
1785            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] findByG_N_D_PrevAndNext(
1786                    long structureId, long groupId, java.lang.String name,
1787                    java.lang.String description,
1788                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1789                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1790    
1791            /**
1792            * Returns all the d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
1793            *
1794            * @param groupId the group ID
1795            * @param name the name
1796            * @param description the description
1797            * @return the matching d d m structures that the user has permission to view
1798            */
1799            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
1800                    long groupId, java.lang.String name, java.lang.String description);
1801    
1802            /**
1803            * 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;.
1804            *
1805            * <p>
1806            * 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.
1807            * </p>
1808            *
1809            * @param groupId the group ID
1810            * @param name the name
1811            * @param description the description
1812            * @param start the lower bound of the range of d d m structures
1813            * @param end the upper bound of the range of d d m structures (not inclusive)
1814            * @return the range of matching d d m structures that the user has permission to view
1815            */
1816            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
1817                    long groupId, java.lang.String name, java.lang.String description,
1818                    int start, int end);
1819    
1820            /**
1821            * 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;.
1822            *
1823            * <p>
1824            * 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.
1825            * </p>
1826            *
1827            * @param groupId the group ID
1828            * @param name the name
1829            * @param description the description
1830            * @param start the lower bound of the range of d d m structures
1831            * @param end the upper bound of the range of d d m structures (not inclusive)
1832            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1833            * @return the ordered range of matching d d m structures that the user has permission to view
1834            */
1835            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> filterFindByG_N_D(
1836                    long groupId, java.lang.String name, java.lang.String description,
1837                    int start, int end,
1838                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1839    
1840            /**
1841            * 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;.
1842            *
1843            * @param structureId the primary key of the current d d m structure
1844            * @param groupId the group ID
1845            * @param name the name
1846            * @param description the description
1847            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1848            * @return the previous, current, and next d d m structure
1849            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1850            */
1851            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure[] filterFindByG_N_D_PrevAndNext(
1852                    long structureId, long groupId, java.lang.String name,
1853                    java.lang.String description,
1854                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator)
1855                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1856    
1857            /**
1858            * Removes all the d d m structures where groupId = &#63; and name = &#63; and description = &#63; from the database.
1859            *
1860            * @param groupId the group ID
1861            * @param name the name
1862            * @param description the description
1863            */
1864            public void removeByG_N_D(long groupId, java.lang.String name,
1865                    java.lang.String description);
1866    
1867            /**
1868            * Returns the number of d d m structures where groupId = &#63; and name = &#63; and description = &#63;.
1869            *
1870            * @param groupId the group ID
1871            * @param name the name
1872            * @param description the description
1873            * @return the number of matching d d m structures
1874            */
1875            public int countByG_N_D(long groupId, java.lang.String name,
1876                    java.lang.String description);
1877    
1878            /**
1879            * Returns the number of d d m structures that the user has permission to view where groupId = &#63; and name = &#63; and description = &#63;.
1880            *
1881            * @param groupId the group ID
1882            * @param name the name
1883            * @param description the description
1884            * @return the number of matching d d m structures that the user has permission to view
1885            */
1886            public int filterCountByG_N_D(long groupId, java.lang.String name,
1887                    java.lang.String description);
1888    
1889            /**
1890            * Caches the d d m structure in the entity cache if it is enabled.
1891            *
1892            * @param ddmStructure the d d m structure
1893            */
1894            public void cacheResult(
1895                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure);
1896    
1897            /**
1898            * Caches the d d m structures in the entity cache if it is enabled.
1899            *
1900            * @param ddmStructures the d d m structures
1901            */
1902            public void cacheResult(
1903                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> ddmStructures);
1904    
1905            /**
1906            * Creates a new d d m structure with the primary key. Does not add the d d m structure to the database.
1907            *
1908            * @param structureId the primary key for the new d d m structure
1909            * @return the new d d m structure
1910            */
1911            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure create(
1912                    long structureId);
1913    
1914            /**
1915            * Removes the d d m structure with the primary key from the database. Also notifies the appropriate model listeners.
1916            *
1917            * @param structureId the primary key of the d d m structure
1918            * @return the d d m structure that was removed
1919            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1920            */
1921            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure remove(
1922                    long structureId)
1923                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1924    
1925            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure updateImpl(
1926                    com.liferay.portlet.dynamicdatamapping.model.DDMStructure ddmStructure);
1927    
1928            /**
1929            * 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.
1930            *
1931            * @param structureId the primary key of the d d m structure
1932            * @return the d d m structure
1933            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException if a d d m structure with the primary key could not be found
1934            */
1935            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure findByPrimaryKey(
1936                    long structureId)
1937                    throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureException;
1938    
1939            /**
1940            * Returns the d d m structure with the primary key or returns <code>null</code> if it could not be found.
1941            *
1942            * @param structureId the primary key of the d d m structure
1943            * @return the d d m structure, or <code>null</code> if a d d m structure with the primary key could not be found
1944            */
1945            public com.liferay.portlet.dynamicdatamapping.model.DDMStructure fetchByPrimaryKey(
1946                    long structureId);
1947    
1948            @Override
1949            public java.util.Map<java.io.Serializable, com.liferay.portlet.dynamicdatamapping.model.DDMStructure> fetchByPrimaryKeys(
1950                    java.util.Set<java.io.Serializable> primaryKeys);
1951    
1952            /**
1953            * Returns all the d d m structures.
1954            *
1955            * @return the d d m structures
1956            */
1957            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll();
1958    
1959            /**
1960            * Returns a range of all the d d m structures.
1961            *
1962            * <p>
1963            * 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.
1964            * </p>
1965            *
1966            * @param start the lower bound of the range of d d m structures
1967            * @param end the upper bound of the range of d d m structures (not inclusive)
1968            * @return the range of d d m structures
1969            */
1970            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
1971                    int start, int end);
1972    
1973            /**
1974            * Returns an ordered range of all the d d m structures.
1975            *
1976            * <p>
1977            * 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.
1978            * </p>
1979            *
1980            * @param start the lower bound of the range of d d m structures
1981            * @param end the upper bound of the range of d d m structures (not inclusive)
1982            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1983            * @return the ordered range of d d m structures
1984            */
1985            public java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> findAll(
1986                    int start, int end,
1987                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.dynamicdatamapping.model.DDMStructure> orderByComparator);
1988    
1989            /**
1990            * Removes all the d d m structures from the database.
1991            */
1992            public void removeAll();
1993    
1994            /**
1995            * Returns the number of d d m structures.
1996            *
1997            * @return the number of d d m structures
1998            */
1999            public int countAll();
2000    
2001            /**
2002            * Returns the primaryKeys of document library file entry types associated with the d d m structure.
2003            *
2004            * @param pk the primary key of the d d m structure
2005            * @return long[] of the primaryKeys of document library file entry types associated with the d d m structure
2006            */
2007            public long[] getDLFileEntryTypePrimaryKeys(long pk);
2008    
2009            /**
2010            * Returns all the document library file entry types associated with the d d m structure.
2011            *
2012            * @param pk the primary key of the d d m structure
2013            * @return the document library file entry types associated with the d d m structure
2014            */
2015            public java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2016                    long pk);
2017    
2018            /**
2019            * Returns a range of all the document library file entry types associated with the d d m structure.
2020            *
2021            * <p>
2022            * 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.
2023            * </p>
2024            *
2025            * @param pk the primary key of the d d m structure
2026            * @param start the lower bound of the range of d d m structures
2027            * @param end the upper bound of the range of d d m structures (not inclusive)
2028            * @return the range of document library file entry types associated with the d d m structure
2029            */
2030            public java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2031                    long pk, int start, int end);
2032    
2033            /**
2034            * Returns an ordered range of all the document library file entry types associated with the d d m structure.
2035            *
2036            * <p>
2037            * 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.
2038            * </p>
2039            *
2040            * @param pk the primary key of the d d m structure
2041            * @param start the lower bound of the range of d d m structures
2042            * @param end the upper bound of the range of d d m structures (not inclusive)
2043            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2044            * @return the ordered range of document library file entry types associated with the d d m structure
2045            */
2046            public java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> getDLFileEntryTypes(
2047                    long pk, int start, int end,
2048                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.documentlibrary.model.DLFileEntryType> orderByComparator);
2049    
2050            /**
2051            * Returns the number of document library file entry types associated with the d d m structure.
2052            *
2053            * @param pk the primary key of the d d m structure
2054            * @return the number of document library file entry types associated with the d d m structure
2055            */
2056            public int getDLFileEntryTypesSize(long pk);
2057    
2058            /**
2059            * Returns <code>true</code> if the document library file entry type is associated with the d d m structure.
2060            *
2061            * @param pk the primary key of the d d m structure
2062            * @param dlFileEntryTypePK the primary key of the document library file entry type
2063            * @return <code>true</code> if the document library file entry type is associated with the d d m structure; <code>false</code> otherwise
2064            */
2065            public boolean containsDLFileEntryType(long pk, long dlFileEntryTypePK);
2066    
2067            /**
2068            * Returns <code>true</code> if the d d m structure has any document library file entry types associated with it.
2069            *
2070            * @param pk the primary key of the d d m structure to check for associations with document library file entry types
2071            * @return <code>true</code> if the d d m structure has any document library file entry types associated with it; <code>false</code> otherwise
2072            */
2073            public boolean containsDLFileEntryTypes(long pk);
2074    
2075            /**
2076            * 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.
2077            *
2078            * @param pk the primary key of the d d m structure
2079            * @param dlFileEntryTypePK the primary key of the document library file entry type
2080            */
2081            public void addDLFileEntryType(long pk, long dlFileEntryTypePK);
2082    
2083            /**
2084            * 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.
2085            *
2086            * @param pk the primary key of the d d m structure
2087            * @param dlFileEntryType the document library file entry type
2088            */
2089            public void addDLFileEntryType(long pk,
2090                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType);
2091    
2092            /**
2093            * 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.
2094            *
2095            * @param pk the primary key of the d d m structure
2096            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2097            */
2098            public void addDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs);
2099    
2100            /**
2101            * 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.
2102            *
2103            * @param pk the primary key of the d d m structure
2104            * @param dlFileEntryTypes the document library file entry types
2105            */
2106            public void addDLFileEntryTypes(long pk,
2107                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes);
2108    
2109            /**
2110            * 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.
2111            *
2112            * @param pk the primary key of the d d m structure to clear the associated document library file entry types from
2113            */
2114            public void clearDLFileEntryTypes(long pk);
2115    
2116            /**
2117            * 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.
2118            *
2119            * @param pk the primary key of the d d m structure
2120            * @param dlFileEntryTypePK the primary key of the document library file entry type
2121            */
2122            public void removeDLFileEntryType(long pk, long dlFileEntryTypePK);
2123    
2124            /**
2125            * 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.
2126            *
2127            * @param pk the primary key of the d d m structure
2128            * @param dlFileEntryType the document library file entry type
2129            */
2130            public void removeDLFileEntryType(long pk,
2131                    com.liferay.portlet.documentlibrary.model.DLFileEntryType dlFileEntryType);
2132    
2133            /**
2134            * 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.
2135            *
2136            * @param pk the primary key of the d d m structure
2137            * @param dlFileEntryTypePKs the primary keys of the document library file entry types
2138            */
2139            public void removeDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs);
2140    
2141            /**
2142            * 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.
2143            *
2144            * @param pk the primary key of the d d m structure
2145            * @param dlFileEntryTypes the document library file entry types
2146            */
2147            public void removeDLFileEntryTypes(long pk,
2148                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes);
2149    
2150            /**
2151            * 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.
2152            *
2153            * @param pk the primary key of the d d m structure
2154            * @param dlFileEntryTypePKs the primary keys of the document library file entry types to be associated with the d d m structure
2155            */
2156            public void setDLFileEntryTypes(long pk, long[] dlFileEntryTypePKs);
2157    
2158            /**
2159            * 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.
2160            *
2161            * @param pk the primary key of the d d m structure
2162            * @param dlFileEntryTypes the document library file entry types to be associated with the d d m structure
2163            */
2164            public void setDLFileEntryTypes(long pk,
2165                    java.util.List<com.liferay.portlet.documentlibrary.model.DLFileEntryType> dlFileEntryTypes);
2166    
2167            /**
2168            * Returns the primaryKeys of journal folders associated with the d d m structure.
2169            *
2170            * @param pk the primary key of the d d m structure
2171            * @return long[] of the primaryKeys of journal folders associated with the d d m structure
2172            */
2173            public long[] getJournalFolderPrimaryKeys(long pk);
2174    
2175            /**
2176            * Returns all the journal folders associated with the d d m structure.
2177            *
2178            * @param pk the primary key of the d d m structure
2179            * @return the journal folders associated with the d d m structure
2180            */
2181            public java.util.List<com.liferay.portlet.journal.model.JournalFolder> getJournalFolders(
2182                    long pk);
2183    
2184            /**
2185            * Returns a range of all the journal folders associated with the d d m structure.
2186            *
2187            * <p>
2188            * 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.
2189            * </p>
2190            *
2191            * @param pk the primary key of the d d m structure
2192            * @param start the lower bound of the range of d d m structures
2193            * @param end the upper bound of the range of d d m structures (not inclusive)
2194            * @return the range of journal folders associated with the d d m structure
2195            */
2196            public java.util.List<com.liferay.portlet.journal.model.JournalFolder> getJournalFolders(
2197                    long pk, int start, int end);
2198    
2199            /**
2200            * Returns an ordered range of all the journal folders associated with the d d m structure.
2201            *
2202            * <p>
2203            * 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.
2204            * </p>
2205            *
2206            * @param pk the primary key of the d d m structure
2207            * @param start the lower bound of the range of d d m structures
2208            * @param end the upper bound of the range of d d m structures (not inclusive)
2209            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2210            * @return the ordered range of journal folders associated with the d d m structure
2211            */
2212            public java.util.List<com.liferay.portlet.journal.model.JournalFolder> getJournalFolders(
2213                    long pk, int start, int end,
2214                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.journal.model.JournalFolder> orderByComparator);
2215    
2216            /**
2217            * Returns the number of journal folders associated with the d d m structure.
2218            *
2219            * @param pk the primary key of the d d m structure
2220            * @return the number of journal folders associated with the d d m structure
2221            */
2222            public int getJournalFoldersSize(long pk);
2223    
2224            /**
2225            * Returns <code>true</code> if the journal folder is associated with the d d m structure.
2226            *
2227            * @param pk the primary key of the d d m structure
2228            * @param journalFolderPK the primary key of the journal folder
2229            * @return <code>true</code> if the journal folder is associated with the d d m structure; <code>false</code> otherwise
2230            */
2231            public boolean containsJournalFolder(long pk, long journalFolderPK);
2232    
2233            /**
2234            * Returns <code>true</code> if the d d m structure has any journal folders associated with it.
2235            *
2236            * @param pk the primary key of the d d m structure to check for associations with journal folders
2237            * @return <code>true</code> if the d d m structure has any journal folders associated with it; <code>false</code> otherwise
2238            */
2239            public boolean containsJournalFolders(long pk);
2240    
2241            /**
2242            * Adds an association between the d d m structure and the journal folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2243            *
2244            * @param pk the primary key of the d d m structure
2245            * @param journalFolderPK the primary key of the journal folder
2246            */
2247            public void addJournalFolder(long pk, long journalFolderPK);
2248    
2249            /**
2250            * Adds an association between the d d m structure and the journal folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2251            *
2252            * @param pk the primary key of the d d m structure
2253            * @param journalFolder the journal folder
2254            */
2255            public void addJournalFolder(long pk,
2256                    com.liferay.portlet.journal.model.JournalFolder journalFolder);
2257    
2258            /**
2259            * Adds an association between the d d m structure and the journal folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2260            *
2261            * @param pk the primary key of the d d m structure
2262            * @param journalFolderPKs the primary keys of the journal folders
2263            */
2264            public void addJournalFolders(long pk, long[] journalFolderPKs);
2265    
2266            /**
2267            * Adds an association between the d d m structure and the journal folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2268            *
2269            * @param pk the primary key of the d d m structure
2270            * @param journalFolders the journal folders
2271            */
2272            public void addJournalFolders(long pk,
2273                    java.util.List<com.liferay.portlet.journal.model.JournalFolder> journalFolders);
2274    
2275            /**
2276            * Clears all associations between the d d m structure and its journal folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2277            *
2278            * @param pk the primary key of the d d m structure to clear the associated journal folders from
2279            */
2280            public void clearJournalFolders(long pk);
2281    
2282            /**
2283            * Removes the association between the d d m structure and the journal folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2284            *
2285            * @param pk the primary key of the d d m structure
2286            * @param journalFolderPK the primary key of the journal folder
2287            */
2288            public void removeJournalFolder(long pk, long journalFolderPK);
2289    
2290            /**
2291            * Removes the association between the d d m structure and the journal folder. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2292            *
2293            * @param pk the primary key of the d d m structure
2294            * @param journalFolder the journal folder
2295            */
2296            public void removeJournalFolder(long pk,
2297                    com.liferay.portlet.journal.model.JournalFolder journalFolder);
2298    
2299            /**
2300            * Removes the association between the d d m structure and the journal folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2301            *
2302            * @param pk the primary key of the d d m structure
2303            * @param journalFolderPKs the primary keys of the journal folders
2304            */
2305            public void removeJournalFolders(long pk, long[] journalFolderPKs);
2306    
2307            /**
2308            * Removes the association between the d d m structure and the journal folders. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2309            *
2310            * @param pk the primary key of the d d m structure
2311            * @param journalFolders the journal folders
2312            */
2313            public void removeJournalFolders(long pk,
2314                    java.util.List<com.liferay.portlet.journal.model.JournalFolder> journalFolders);
2315    
2316            /**
2317            * Sets the journal folders associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2318            *
2319            * @param pk the primary key of the d d m structure
2320            * @param journalFolderPKs the primary keys of the journal folders to be associated with the d d m structure
2321            */
2322            public void setJournalFolders(long pk, long[] journalFolderPKs);
2323    
2324            /**
2325            * Sets the journal folders associated with the d d m structure, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache.
2326            *
2327            * @param pk the primary key of the d d m structure
2328            * @param journalFolders the journal folders to be associated with the d d m structure
2329            */
2330            public void setJournalFolders(long pk,
2331                    java.util.List<com.liferay.portlet.journal.model.JournalFolder> journalFolders);
2332    }