001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.dynamicdatamapping.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.dynamicdatamapping.model.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 the d d m template where groupId = &#63; and templateKey = &#63; or throws a {@link com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException} if it could not be found.
1684            *
1685            * @param groupId the group ID
1686            * @param templateKey the template key
1687            * @return the matching d d m template
1688            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
1689            * @throws SystemException if a system exception occurred
1690            */
1691            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByG_T(
1692                    long groupId, java.lang.String templateKey)
1693                    throws com.liferay.portal.kernel.exception.SystemException,
1694                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
1695                    return getPersistence().findByG_T(groupId, templateKey);
1696            }
1697    
1698            /**
1699            * Returns the d d m template where groupId = &#63; and templateKey = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1700            *
1701            * @param groupId the group ID
1702            * @param templateKey the template key
1703            * @return the matching d d m template, or <code>null</code> if a matching d d m template could not be found
1704            * @throws SystemException if a system exception occurred
1705            */
1706            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByG_T(
1707                    long groupId, java.lang.String templateKey)
1708                    throws com.liferay.portal.kernel.exception.SystemException {
1709                    return getPersistence().fetchByG_T(groupId, templateKey);
1710            }
1711    
1712            /**
1713            * Returns the d d m template where groupId = &#63; and templateKey = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1714            *
1715            * @param groupId the group ID
1716            * @param templateKey the template key
1717            * @param retrieveFromCache whether to use the finder cache
1718            * @return the matching d d m template, or <code>null</code> if a matching d d m template could not be found
1719            * @throws SystemException if a system exception occurred
1720            */
1721            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByG_T(
1722                    long groupId, java.lang.String templateKey, boolean retrieveFromCache)
1723                    throws com.liferay.portal.kernel.exception.SystemException {
1724                    return getPersistence()
1725                                       .fetchByG_T(groupId, templateKey, retrieveFromCache);
1726            }
1727    
1728            /**
1729            * Removes the d d m template where groupId = &#63; and templateKey = &#63; from the database.
1730            *
1731            * @param groupId the group ID
1732            * @param templateKey the template key
1733            * @return the d d m template that was removed
1734            * @throws SystemException if a system exception occurred
1735            */
1736            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate removeByG_T(
1737                    long groupId, java.lang.String templateKey)
1738                    throws com.liferay.portal.kernel.exception.SystemException,
1739                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
1740                    return getPersistence().removeByG_T(groupId, templateKey);
1741            }
1742    
1743            /**
1744            * Returns the number of d d m templates where groupId = &#63; and templateKey = &#63;.
1745            *
1746            * @param groupId the group ID
1747            * @param templateKey the template key
1748            * @return the number of matching d d m templates
1749            * @throws SystemException if a system exception occurred
1750            */
1751            public static int countByG_T(long groupId, java.lang.String templateKey)
1752                    throws com.liferay.portal.kernel.exception.SystemException {
1753                    return getPersistence().countByG_T(groupId, templateKey);
1754            }
1755    
1756            /**
1757            * Returns all the d d m templates where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1758            *
1759            * @param groupId the group ID
1760            * @param classNameId the class name ID
1761            * @param classPK the class p k
1762            * @return the matching d d m templates
1763            * @throws SystemException if a system exception occurred
1764            */
1765            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByG_C_C(
1766                    long groupId, long classNameId, long classPK)
1767                    throws com.liferay.portal.kernel.exception.SystemException {
1768                    return getPersistence().findByG_C_C(groupId, classNameId, classPK);
1769            }
1770    
1771            /**
1772            * Returns a range of all the d d m templates where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1773            *
1774            * <p>
1775            * 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.
1776            * </p>
1777            *
1778            * @param groupId the group ID
1779            * @param classNameId the class name ID
1780            * @param classPK the class p k
1781            * @param start the lower bound of the range of d d m templates
1782            * @param end the upper bound of the range of d d m templates (not inclusive)
1783            * @return the range of matching d d m templates
1784            * @throws SystemException if a system exception occurred
1785            */
1786            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByG_C_C(
1787                    long groupId, long classNameId, long classPK, int start, int end)
1788                    throws com.liferay.portal.kernel.exception.SystemException {
1789                    return getPersistence()
1790                                       .findByG_C_C(groupId, classNameId, classPK, start, end);
1791            }
1792    
1793            /**
1794            * Returns an ordered range of all the d d m templates where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1795            *
1796            * <p>
1797            * 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.
1798            * </p>
1799            *
1800            * @param groupId the group ID
1801            * @param classNameId the class name ID
1802            * @param classPK the class p k
1803            * @param start the lower bound of the range of d d m templates
1804            * @param end the upper bound of the range of d d m templates (not inclusive)
1805            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1806            * @return the ordered range of matching d d m templates
1807            * @throws SystemException if a system exception occurred
1808            */
1809            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByG_C_C(
1810                    long groupId, long classNameId, long classPK, int start, int end,
1811                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1812                    throws com.liferay.portal.kernel.exception.SystemException {
1813                    return getPersistence()
1814                                       .findByG_C_C(groupId, classNameId, classPK, start, end,
1815                            orderByComparator);
1816            }
1817    
1818            /**
1819            * Returns the first d d m template in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1820            *
1821            * @param groupId the group ID
1822            * @param classNameId the class name ID
1823            * @param classPK the class p k
1824            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1825            * @return the first matching d d m template
1826            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
1827            * @throws SystemException if a system exception occurred
1828            */
1829            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByG_C_C_First(
1830                    long groupId, long classNameId, long classPK,
1831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1832                    throws com.liferay.portal.kernel.exception.SystemException,
1833                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
1834                    return getPersistence()
1835                                       .findByG_C_C_First(groupId, classNameId, classPK,
1836                            orderByComparator);
1837            }
1838    
1839            /**
1840            * Returns the first d d m template in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1841            *
1842            * @param groupId the group ID
1843            * @param classNameId the class name ID
1844            * @param classPK the class p k
1845            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1846            * @return the first matching d d m template, or <code>null</code> if a matching d d m template could not be found
1847            * @throws SystemException if a system exception occurred
1848            */
1849            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByG_C_C_First(
1850                    long groupId, long classNameId, long classPK,
1851                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1852                    throws com.liferay.portal.kernel.exception.SystemException {
1853                    return getPersistence()
1854                                       .fetchByG_C_C_First(groupId, classNameId, classPK,
1855                            orderByComparator);
1856            }
1857    
1858            /**
1859            * Returns the last d d m template in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1860            *
1861            * @param groupId the group ID
1862            * @param classNameId the class name ID
1863            * @param classPK the class p k
1864            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1865            * @return the last matching d d m template
1866            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
1867            * @throws SystemException if a system exception occurred
1868            */
1869            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByG_C_C_Last(
1870                    long groupId, long classNameId, long classPK,
1871                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1872                    throws com.liferay.portal.kernel.exception.SystemException,
1873                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
1874                    return getPersistence()
1875                                       .findByG_C_C_Last(groupId, classNameId, classPK,
1876                            orderByComparator);
1877            }
1878    
1879            /**
1880            * Returns the last d d m template in the ordered set where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1881            *
1882            * @param groupId the group ID
1883            * @param classNameId the class name ID
1884            * @param classPK the class p k
1885            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1886            * @return the last matching d d m template, or <code>null</code> if a matching d d m template could not be found
1887            * @throws SystemException if a system exception occurred
1888            */
1889            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByG_C_C_Last(
1890                    long groupId, long classNameId, long classPK,
1891                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1892                    throws com.liferay.portal.kernel.exception.SystemException {
1893                    return getPersistence()
1894                                       .fetchByG_C_C_Last(groupId, classNameId, classPK,
1895                            orderByComparator);
1896            }
1897    
1898            /**
1899            * 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;.
1900            *
1901            * @param templateId the primary key of the current d d m template
1902            * @param groupId the group ID
1903            * @param classNameId the class name ID
1904            * @param classPK the class p k
1905            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1906            * @return the previous, current, and next d d m template
1907            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a d d m template with the primary key could not be found
1908            * @throws SystemException if a system exception occurred
1909            */
1910            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate[] findByG_C_C_PrevAndNext(
1911                    long templateId, long groupId, long classNameId, long classPK,
1912                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1913                    throws com.liferay.portal.kernel.exception.SystemException,
1914                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
1915                    return getPersistence()
1916                                       .findByG_C_C_PrevAndNext(templateId, groupId, classNameId,
1917                            classPK, orderByComparator);
1918            }
1919    
1920            /**
1921            * Returns all the d d m templates that the user has permission to view where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
1922            *
1923            * @param groupId the group ID
1924            * @param classNameId the class name ID
1925            * @param classPK the class p k
1926            * @return the matching d d m templates that the user has permission to view
1927            * @throws SystemException if a system exception occurred
1928            */
1929            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> filterFindByG_C_C(
1930                    long groupId, long classNameId, long classPK)
1931                    throws com.liferay.portal.kernel.exception.SystemException {
1932                    return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK);
1933            }
1934    
1935            /**
1936            * 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;.
1937            *
1938            * <p>
1939            * 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.
1940            * </p>
1941            *
1942            * @param groupId the group ID
1943            * @param classNameId the class name ID
1944            * @param classPK the class p k
1945            * @param start the lower bound of the range of d d m templates
1946            * @param end the upper bound of the range of d d m templates (not inclusive)
1947            * @return the range of matching d d m templates that the user has permission to view
1948            * @throws SystemException if a system exception occurred
1949            */
1950            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> filterFindByG_C_C(
1951                    long groupId, long classNameId, long classPK, int start, int end)
1952                    throws com.liferay.portal.kernel.exception.SystemException {
1953                    return getPersistence()
1954                                       .filterFindByG_C_C(groupId, classNameId, classPK, start, end);
1955            }
1956    
1957            /**
1958            * 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;.
1959            *
1960            * <p>
1961            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.dynamicdatamapping.model.impl.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.
1962            * </p>
1963            *
1964            * @param groupId the group ID
1965            * @param classNameId the class name ID
1966            * @param classPK the class p k
1967            * @param start the lower bound of the range of d d m templates
1968            * @param end the upper bound of the range of d d m templates (not inclusive)
1969            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1970            * @return the ordered range of matching d d m templates that the user has permission to view
1971            * @throws SystemException if a system exception occurred
1972            */
1973            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> filterFindByG_C_C(
1974                    long groupId, long classNameId, long classPK, int start, int end,
1975                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1976                    throws com.liferay.portal.kernel.exception.SystemException {
1977                    return getPersistence()
1978                                       .filterFindByG_C_C(groupId, classNameId, classPK, start,
1979                            end, orderByComparator);
1980            }
1981    
1982            /**
1983            * 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;.
1984            *
1985            * @param templateId the primary key of the current d d m template
1986            * @param groupId the group ID
1987            * @param classNameId the class name ID
1988            * @param classPK the class p k
1989            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1990            * @return the previous, current, and next d d m template
1991            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a d d m template with the primary key could not be found
1992            * @throws SystemException if a system exception occurred
1993            */
1994            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate[] filterFindByG_C_C_PrevAndNext(
1995                    long templateId, long groupId, long classNameId, long classPK,
1996                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1997                    throws com.liferay.portal.kernel.exception.SystemException,
1998                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
1999                    return getPersistence()
2000                                       .filterFindByG_C_C_PrevAndNext(templateId, groupId,
2001                            classNameId, classPK, orderByComparator);
2002            }
2003    
2004            /**
2005            * Removes all the d d m templates where groupId = &#63; and classNameId = &#63; and classPK = &#63; from the database.
2006            *
2007            * @param groupId the group ID
2008            * @param classNameId the class name ID
2009            * @param classPK the class p k
2010            * @throws SystemException if a system exception occurred
2011            */
2012            public static void removeByG_C_C(long groupId, long classNameId,
2013                    long classPK)
2014                    throws com.liferay.portal.kernel.exception.SystemException {
2015                    getPersistence().removeByG_C_C(groupId, classNameId, classPK);
2016            }
2017    
2018            /**
2019            * Returns the number of d d m templates where groupId = &#63; and classNameId = &#63; and classPK = &#63;.
2020            *
2021            * @param groupId the group ID
2022            * @param classNameId the class name ID
2023            * @param classPK the class p k
2024            * @return the number of matching d d m templates
2025            * @throws SystemException if a system exception occurred
2026            */
2027            public static int countByG_C_C(long groupId, long classNameId, long classPK)
2028                    throws com.liferay.portal.kernel.exception.SystemException {
2029                    return getPersistence().countByG_C_C(groupId, classNameId, classPK);
2030            }
2031    
2032            /**
2033            * Returns the number of d d m templates that the user has permission to view 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            * @return the number of matching d d m templates that the user has permission to view
2039            * @throws SystemException if a system exception occurred
2040            */
2041            public static int filterCountByG_C_C(long groupId, long classNameId,
2042                    long classPK)
2043                    throws com.liferay.portal.kernel.exception.SystemException {
2044                    return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK);
2045            }
2046    
2047            /**
2048            * Returns all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63;.
2049            *
2050            * @param classNameId the class name ID
2051            * @param classPK the class p k
2052            * @param type the type
2053            * @return the matching d d m templates
2054            * @throws SystemException if a system exception occurred
2055            */
2056            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByC_C_T(
2057                    long classNameId, long classPK, java.lang.String type)
2058                    throws com.liferay.portal.kernel.exception.SystemException {
2059                    return getPersistence().findByC_C_T(classNameId, classPK, type);
2060            }
2061    
2062            /**
2063            * Returns a range of all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63;.
2064            *
2065            * <p>
2066            * 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.
2067            * </p>
2068            *
2069            * @param classNameId the class name ID
2070            * @param classPK the class p k
2071            * @param type the type
2072            * @param start the lower bound of the range of d d m templates
2073            * @param end the upper bound of the range of d d m templates (not inclusive)
2074            * @return the range of matching d d m templates
2075            * @throws SystemException if a system exception occurred
2076            */
2077            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByC_C_T(
2078                    long classNameId, long classPK, java.lang.String type, int start,
2079                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2080                    return getPersistence()
2081                                       .findByC_C_T(classNameId, classPK, type, start, end);
2082            }
2083    
2084            /**
2085            * Returns an ordered range of all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63;.
2086            *
2087            * <p>
2088            * 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.
2089            * </p>
2090            *
2091            * @param classNameId the class name ID
2092            * @param classPK the class p k
2093            * @param type the type
2094            * @param start the lower bound of the range of d d m templates
2095            * @param end the upper bound of the range of d d m templates (not inclusive)
2096            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2097            * @return the ordered range of matching d d m templates
2098            * @throws SystemException if a system exception occurred
2099            */
2100            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByC_C_T(
2101                    long classNameId, long classPK, java.lang.String type, int start,
2102                    int end,
2103                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2104                    throws com.liferay.portal.kernel.exception.SystemException {
2105                    return getPersistence()
2106                                       .findByC_C_T(classNameId, classPK, type, start, end,
2107                            orderByComparator);
2108            }
2109    
2110            /**
2111            * Returns the first d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
2112            *
2113            * @param classNameId the class name ID
2114            * @param classPK the class p k
2115            * @param type the type
2116            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2117            * @return the first matching d d m template
2118            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
2119            * @throws SystemException if a system exception occurred
2120            */
2121            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByC_C_T_First(
2122                    long classNameId, long classPK, java.lang.String type,
2123                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2124                    throws com.liferay.portal.kernel.exception.SystemException,
2125                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2126                    return getPersistence()
2127                                       .findByC_C_T_First(classNameId, classPK, type,
2128                            orderByComparator);
2129            }
2130    
2131            /**
2132            * Returns the first d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
2133            *
2134            * @param classNameId the class name ID
2135            * @param classPK the class p k
2136            * @param type the type
2137            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2138            * @return the first matching d d m template, or <code>null</code> if a matching d d m template could not be found
2139            * @throws SystemException if a system exception occurred
2140            */
2141            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByC_C_T_First(
2142                    long classNameId, long classPK, java.lang.String type,
2143                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2144                    throws com.liferay.portal.kernel.exception.SystemException {
2145                    return getPersistence()
2146                                       .fetchByC_C_T_First(classNameId, classPK, type,
2147                            orderByComparator);
2148            }
2149    
2150            /**
2151            * Returns the last d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
2152            *
2153            * @param classNameId the class name ID
2154            * @param classPK the class p k
2155            * @param type the type
2156            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2157            * @return the last matching d d m template
2158            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
2159            * @throws SystemException if a system exception occurred
2160            */
2161            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByC_C_T_Last(
2162                    long classNameId, long classPK, java.lang.String type,
2163                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2164                    throws com.liferay.portal.kernel.exception.SystemException,
2165                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2166                    return getPersistence()
2167                                       .findByC_C_T_Last(classNameId, classPK, type,
2168                            orderByComparator);
2169            }
2170    
2171            /**
2172            * Returns the last d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63;.
2173            *
2174            * @param classNameId the class name ID
2175            * @param classPK the class p k
2176            * @param type the type
2177            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2178            * @return the last matching d d m template, or <code>null</code> if a matching d d m template could not be found
2179            * @throws SystemException if a system exception occurred
2180            */
2181            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByC_C_T_Last(
2182                    long classNameId, long classPK, java.lang.String type,
2183                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2184                    throws com.liferay.portal.kernel.exception.SystemException {
2185                    return getPersistence()
2186                                       .fetchByC_C_T_Last(classNameId, classPK, type,
2187                            orderByComparator);
2188            }
2189    
2190            /**
2191            * 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;.
2192            *
2193            * @param templateId the primary key of the current d d m template
2194            * @param classNameId the class name ID
2195            * @param classPK the class p k
2196            * @param type the type
2197            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2198            * @return the previous, current, and next d d m template
2199            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a d d m template with the primary key could not be found
2200            * @throws SystemException if a system exception occurred
2201            */
2202            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate[] findByC_C_T_PrevAndNext(
2203                    long templateId, long classNameId, long classPK, java.lang.String type,
2204                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2205                    throws com.liferay.portal.kernel.exception.SystemException,
2206                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2207                    return getPersistence()
2208                                       .findByC_C_T_PrevAndNext(templateId, classNameId, classPK,
2209                            type, orderByComparator);
2210            }
2211    
2212            /**
2213            * Removes all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63; from the database.
2214            *
2215            * @param classNameId the class name ID
2216            * @param classPK the class p k
2217            * @param type the type
2218            * @throws SystemException if a system exception occurred
2219            */
2220            public static void removeByC_C_T(long classNameId, long classPK,
2221                    java.lang.String type)
2222                    throws com.liferay.portal.kernel.exception.SystemException {
2223                    getPersistence().removeByC_C_T(classNameId, classPK, type);
2224            }
2225    
2226            /**
2227            * Returns the number of d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63;.
2228            *
2229            * @param classNameId the class name ID
2230            * @param classPK the class p k
2231            * @param type the type
2232            * @return the number of matching d d m templates
2233            * @throws SystemException if a system exception occurred
2234            */
2235            public static int countByC_C_T(long classNameId, long classPK,
2236                    java.lang.String type)
2237                    throws com.liferay.portal.kernel.exception.SystemException {
2238                    return getPersistence().countByC_C_T(classNameId, classPK, type);
2239            }
2240    
2241            /**
2242            * Returns all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2243            *
2244            * @param classNameId the class name ID
2245            * @param classPK the class p k
2246            * @param type the type
2247            * @param mode the mode
2248            * @return the matching d d m templates
2249            * @throws SystemException if a system exception occurred
2250            */
2251            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByC_C_T_M(
2252                    long classNameId, long classPK, java.lang.String type,
2253                    java.lang.String mode)
2254                    throws com.liferay.portal.kernel.exception.SystemException {
2255                    return getPersistence().findByC_C_T_M(classNameId, classPK, type, mode);
2256            }
2257    
2258            /**
2259            * Returns a range of all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2260            *
2261            * <p>
2262            * 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.
2263            * </p>
2264            *
2265            * @param classNameId the class name ID
2266            * @param classPK the class p k
2267            * @param type the type
2268            * @param mode the mode
2269            * @param start the lower bound of the range of d d m templates
2270            * @param end the upper bound of the range of d d m templates (not inclusive)
2271            * @return the range of matching d d m templates
2272            * @throws SystemException if a system exception occurred
2273            */
2274            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByC_C_T_M(
2275                    long classNameId, long classPK, java.lang.String type,
2276                    java.lang.String mode, int start, int end)
2277                    throws com.liferay.portal.kernel.exception.SystemException {
2278                    return getPersistence()
2279                                       .findByC_C_T_M(classNameId, classPK, type, mode, start, end);
2280            }
2281    
2282            /**
2283            * Returns an ordered range of all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2284            *
2285            * <p>
2286            * 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.
2287            * </p>
2288            *
2289            * @param classNameId the class name ID
2290            * @param classPK the class p k
2291            * @param type the type
2292            * @param mode the mode
2293            * @param start the lower bound of the range of d d m templates
2294            * @param end the upper bound of the range of d d m templates (not inclusive)
2295            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2296            * @return the ordered range of matching d d m templates
2297            * @throws SystemException if a system exception occurred
2298            */
2299            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findByC_C_T_M(
2300                    long classNameId, long classPK, java.lang.String type,
2301                    java.lang.String mode, int start, int end,
2302                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2303                    throws com.liferay.portal.kernel.exception.SystemException {
2304                    return getPersistence()
2305                                       .findByC_C_T_M(classNameId, classPK, type, mode, start, end,
2306                            orderByComparator);
2307            }
2308    
2309            /**
2310            * Returns the first d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2311            *
2312            * @param classNameId the class name ID
2313            * @param classPK the class p k
2314            * @param type the type
2315            * @param mode the mode
2316            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2317            * @return the first matching d d m template
2318            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
2319            * @throws SystemException if a system exception occurred
2320            */
2321            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByC_C_T_M_First(
2322                    long classNameId, long classPK, java.lang.String type,
2323                    java.lang.String mode,
2324                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2325                    throws com.liferay.portal.kernel.exception.SystemException,
2326                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2327                    return getPersistence()
2328                                       .findByC_C_T_M_First(classNameId, classPK, type, mode,
2329                            orderByComparator);
2330            }
2331    
2332            /**
2333            * Returns the first d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2334            *
2335            * @param classNameId the class name ID
2336            * @param classPK the class p k
2337            * @param type the type
2338            * @param mode the mode
2339            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2340            * @return the first matching d d m template, or <code>null</code> if a matching d d m template could not be found
2341            * @throws SystemException if a system exception occurred
2342            */
2343            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByC_C_T_M_First(
2344                    long classNameId, long classPK, java.lang.String type,
2345                    java.lang.String mode,
2346                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2347                    throws com.liferay.portal.kernel.exception.SystemException {
2348                    return getPersistence()
2349                                       .fetchByC_C_T_M_First(classNameId, classPK, type, mode,
2350                            orderByComparator);
2351            }
2352    
2353            /**
2354            * Returns the last d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2355            *
2356            * @param classNameId the class name ID
2357            * @param classPK the class p k
2358            * @param type the type
2359            * @param mode the mode
2360            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2361            * @return the last matching d d m template
2362            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a matching d d m template could not be found
2363            * @throws SystemException if a system exception occurred
2364            */
2365            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByC_C_T_M_Last(
2366                    long classNameId, long classPK, java.lang.String type,
2367                    java.lang.String mode,
2368                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2369                    throws com.liferay.portal.kernel.exception.SystemException,
2370                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2371                    return getPersistence()
2372                                       .findByC_C_T_M_Last(classNameId, classPK, type, mode,
2373                            orderByComparator);
2374            }
2375    
2376            /**
2377            * Returns the last d d m template in the ordered set where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2378            *
2379            * @param classNameId the class name ID
2380            * @param classPK the class p k
2381            * @param type the type
2382            * @param mode the mode
2383            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2384            * @return the last matching d d m template, or <code>null</code> if a matching d d m template could not be found
2385            * @throws SystemException if a system exception occurred
2386            */
2387            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByC_C_T_M_Last(
2388                    long classNameId, long classPK, java.lang.String type,
2389                    java.lang.String mode,
2390                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2391                    throws com.liferay.portal.kernel.exception.SystemException {
2392                    return getPersistence()
2393                                       .fetchByC_C_T_M_Last(classNameId, classPK, type, mode,
2394                            orderByComparator);
2395            }
2396    
2397            /**
2398            * 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; and mode = &#63;.
2399            *
2400            * @param templateId the primary key of the current d d m template
2401            * @param classNameId the class name ID
2402            * @param classPK the class p k
2403            * @param type the type
2404            * @param mode the mode
2405            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2406            * @return the previous, current, and next d d m template
2407            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a d d m template with the primary key could not be found
2408            * @throws SystemException if a system exception occurred
2409            */
2410            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate[] findByC_C_T_M_PrevAndNext(
2411                    long templateId, long classNameId, long classPK, java.lang.String type,
2412                    java.lang.String mode,
2413                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2414                    throws com.liferay.portal.kernel.exception.SystemException,
2415                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2416                    return getPersistence()
2417                                       .findByC_C_T_M_PrevAndNext(templateId, classNameId, classPK,
2418                            type, mode, orderByComparator);
2419            }
2420    
2421            /**
2422            * Removes all the d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63; from the database.
2423            *
2424            * @param classNameId the class name ID
2425            * @param classPK the class p k
2426            * @param type the type
2427            * @param mode the mode
2428            * @throws SystemException if a system exception occurred
2429            */
2430            public static void removeByC_C_T_M(long classNameId, long classPK,
2431                    java.lang.String type, java.lang.String mode)
2432                    throws com.liferay.portal.kernel.exception.SystemException {
2433                    getPersistence().removeByC_C_T_M(classNameId, classPK, type, mode);
2434            }
2435    
2436            /**
2437            * Returns the number of d d m templates where classNameId = &#63; and classPK = &#63; and type = &#63; and mode = &#63;.
2438            *
2439            * @param classNameId the class name ID
2440            * @param classPK the class p k
2441            * @param type the type
2442            * @param mode the mode
2443            * @return the number of matching d d m templates
2444            * @throws SystemException if a system exception occurred
2445            */
2446            public static int countByC_C_T_M(long classNameId, long classPK,
2447                    java.lang.String type, java.lang.String mode)
2448                    throws com.liferay.portal.kernel.exception.SystemException {
2449                    return getPersistence().countByC_C_T_M(classNameId, classPK, type, mode);
2450            }
2451    
2452            /**
2453            * Caches the d d m template in the entity cache if it is enabled.
2454            *
2455            * @param ddmTemplate the d d m template
2456            */
2457            public static void cacheResult(
2458                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate ddmTemplate) {
2459                    getPersistence().cacheResult(ddmTemplate);
2460            }
2461    
2462            /**
2463            * Caches the d d m templates in the entity cache if it is enabled.
2464            *
2465            * @param ddmTemplates the d d m templates
2466            */
2467            public static void cacheResult(
2468                    java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> ddmTemplates) {
2469                    getPersistence().cacheResult(ddmTemplates);
2470            }
2471    
2472            /**
2473            * Creates a new d d m template with the primary key. Does not add the d d m template to the database.
2474            *
2475            * @param templateId the primary key for the new d d m template
2476            * @return the new d d m template
2477            */
2478            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate create(
2479                    long templateId) {
2480                    return getPersistence().create(templateId);
2481            }
2482    
2483            /**
2484            * Removes the d d m template with the primary key from the database. Also notifies the appropriate model listeners.
2485            *
2486            * @param templateId the primary key of the d d m template
2487            * @return the d d m template that was removed
2488            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a d d m template with the primary key could not be found
2489            * @throws SystemException if a system exception occurred
2490            */
2491            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate remove(
2492                    long templateId)
2493                    throws com.liferay.portal.kernel.exception.SystemException,
2494                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2495                    return getPersistence().remove(templateId);
2496            }
2497    
2498            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate updateImpl(
2499                    com.liferay.portlet.dynamicdatamapping.model.DDMTemplate ddmTemplate)
2500                    throws com.liferay.portal.kernel.exception.SystemException {
2501                    return getPersistence().updateImpl(ddmTemplate);
2502            }
2503    
2504            /**
2505            * 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.
2506            *
2507            * @param templateId the primary key of the d d m template
2508            * @return the d d m template
2509            * @throws com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException if a d d m template with the primary key could not be found
2510            * @throws SystemException if a system exception occurred
2511            */
2512            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate findByPrimaryKey(
2513                    long templateId)
2514                    throws com.liferay.portal.kernel.exception.SystemException,
2515                            com.liferay.portlet.dynamicdatamapping.NoSuchTemplateException {
2516                    return getPersistence().findByPrimaryKey(templateId);
2517            }
2518    
2519            /**
2520            * Returns the d d m template with the primary key or returns <code>null</code> if it could not be found.
2521            *
2522            * @param templateId the primary key of the d d m template
2523            * @return the d d m template, or <code>null</code> if a d d m template with the primary key could not be found
2524            * @throws SystemException if a system exception occurred
2525            */
2526            public static com.liferay.portlet.dynamicdatamapping.model.DDMTemplate fetchByPrimaryKey(
2527                    long templateId)
2528                    throws com.liferay.portal.kernel.exception.SystemException {
2529                    return getPersistence().fetchByPrimaryKey(templateId);
2530            }
2531    
2532            /**
2533            * Returns all the d d m templates.
2534            *
2535            * @return the d d m templates
2536            * @throws SystemException if a system exception occurred
2537            */
2538            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findAll()
2539                    throws com.liferay.portal.kernel.exception.SystemException {
2540                    return getPersistence().findAll();
2541            }
2542    
2543            /**
2544            * Returns a range of all the d d m templates.
2545            *
2546            * <p>
2547            * 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.
2548            * </p>
2549            *
2550            * @param start the lower bound of the range of d d m templates
2551            * @param end the upper bound of the range of d d m templates (not inclusive)
2552            * @return the range of d d m templates
2553            * @throws SystemException if a system exception occurred
2554            */
2555            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findAll(
2556                    int start, int end)
2557                    throws com.liferay.portal.kernel.exception.SystemException {
2558                    return getPersistence().findAll(start, end);
2559            }
2560    
2561            /**
2562            * Returns an ordered range of all the d d m templates.
2563            *
2564            * <p>
2565            * 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.
2566            * </p>
2567            *
2568            * @param start the lower bound of the range of d d m templates
2569            * @param end the upper bound of the range of d d m templates (not inclusive)
2570            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2571            * @return the ordered range of d d m templates
2572            * @throws SystemException if a system exception occurred
2573            */
2574            public static java.util.List<com.liferay.portlet.dynamicdatamapping.model.DDMTemplate> findAll(
2575                    int start, int end,
2576                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2577                    throws com.liferay.portal.kernel.exception.SystemException {
2578                    return getPersistence().findAll(start, end, orderByComparator);
2579            }
2580    
2581            /**
2582            * Removes all the d d m templates from the database.
2583            *
2584            * @throws SystemException if a system exception occurred
2585            */
2586            public static void removeAll()
2587                    throws com.liferay.portal.kernel.exception.SystemException {
2588                    getPersistence().removeAll();
2589            }
2590    
2591            /**
2592            * Returns the number of d d m templates.
2593            *
2594            * @return the number of d d m templates
2595            * @throws SystemException if a system exception occurred
2596            */
2597            public static int countAll()
2598                    throws com.liferay.portal.kernel.exception.SystemException {
2599                    return getPersistence().countAll();
2600            }
2601    
2602            public static DDMTemplatePersistence getPersistence() {
2603                    if (_persistence == null) {
2604                            _persistence = (DDMTemplatePersistence)PortalBeanLocatorUtil.locate(DDMTemplatePersistence.class.getName());
2605    
2606                            ReferenceRegistry.registerReference(DDMTemplateUtil.class,
2607                                    "_persistence");
2608                    }
2609    
2610                    return _persistence;
2611            }
2612    
2613            /**
2614             * @deprecated
2615             */
2616            public void setPersistence(DDMTemplatePersistence persistence) {
2617            }
2618    
2619            private static DDMTemplatePersistence _persistence;
2620    }