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