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