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