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