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