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.DDMStructureVersion; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the d d m structure version service. This utility wraps {@link com.liferay.portlet.dynamicdatamapping.service.persistence.impl.DDMStructureVersionPersistenceImpl} 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 DDMStructureVersionPersistence 038 * @see com.liferay.portlet.dynamicdatamapping.service.persistence.impl.DDMStructureVersionPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class DDMStructureVersionUtil { 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(DDMStructureVersion ddmStructureVersion) { 060 getPersistence().clearCache(ddmStructureVersion); 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<DDMStructureVersion> 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<DDMStructureVersion> 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<DDMStructureVersion> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<DDMStructureVersion> 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 DDMStructureVersion update( 101 DDMStructureVersion ddmStructureVersion) { 102 return getPersistence().update(ddmStructureVersion); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static DDMStructureVersion update( 109 DDMStructureVersion ddmStructureVersion, ServiceContext serviceContext) { 110 return getPersistence().update(ddmStructureVersion, serviceContext); 111 } 112 113 /** 114 * Returns all the d d m structure versions where structureId = ?. 115 * 116 * @param structureId the structure ID 117 * @return the matching d d m structure versions 118 */ 119 public static List<DDMStructureVersion> findByStructureId(long structureId) { 120 return getPersistence().findByStructureId(structureId); 121 } 122 123 /** 124 * Returns a range of all the d d m structure versions where structureId = ?. 125 * 126 * <p> 127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 DDMStructureVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 128 * </p> 129 * 130 * @param structureId the structure ID 131 * @param start the lower bound of the range of d d m structure versions 132 * @param end the upper bound of the range of d d m structure versions (not inclusive) 133 * @return the range of matching d d m structure versions 134 */ 135 public static List<DDMStructureVersion> findByStructureId( 136 long structureId, int start, int end) { 137 return getPersistence().findByStructureId(structureId, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the d d m structure versions where structureId = ?. 142 * 143 * <p> 144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 DDMStructureVersionModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 145 * </p> 146 * 147 * @param structureId the structure ID 148 * @param start the lower bound of the range of d d m structure versions 149 * @param end the upper bound of the range of d d m structure versions (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching d d m structure versions 152 */ 153 public static List<DDMStructureVersion> findByStructureId( 154 long structureId, int start, int end, 155 OrderByComparator<DDMStructureVersion> orderByComparator) { 156 return getPersistence() 157 .findByStructureId(structureId, start, end, orderByComparator); 158 } 159 160 /** 161 * Returns the first d d m structure version in the ordered set where structureId = ?. 162 * 163 * @param structureId the structure ID 164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 165 * @return the first matching d d m structure version 166 * @throws NoSuchStructureVersionException if a matching d d m structure version could not be found 167 */ 168 public static DDMStructureVersion findByStructureId_First( 169 long structureId, 170 OrderByComparator<DDMStructureVersion> orderByComparator) 171 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 172 return getPersistence() 173 .findByStructureId_First(structureId, orderByComparator); 174 } 175 176 /** 177 * Returns the first d d m structure version in the ordered set where structureId = ?. 178 * 179 * @param structureId the structure ID 180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 181 * @return the first matching d d m structure version, or <code>null</code> if a matching d d m structure version could not be found 182 */ 183 public static DDMStructureVersion fetchByStructureId_First( 184 long structureId, 185 OrderByComparator<DDMStructureVersion> orderByComparator) { 186 return getPersistence() 187 .fetchByStructureId_First(structureId, orderByComparator); 188 } 189 190 /** 191 * Returns the last d d m structure version in the ordered set where structureId = ?. 192 * 193 * @param structureId the structure ID 194 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 195 * @return the last matching d d m structure version 196 * @throws NoSuchStructureVersionException if a matching d d m structure version could not be found 197 */ 198 public static DDMStructureVersion findByStructureId_Last(long structureId, 199 OrderByComparator<DDMStructureVersion> orderByComparator) 200 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 201 return getPersistence() 202 .findByStructureId_Last(structureId, orderByComparator); 203 } 204 205 /** 206 * Returns the last d d m structure version in the ordered set where structureId = ?. 207 * 208 * @param structureId the structure ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching d d m structure version, or <code>null</code> if a matching d d m structure version could not be found 211 */ 212 public static DDMStructureVersion fetchByStructureId_Last( 213 long structureId, 214 OrderByComparator<DDMStructureVersion> orderByComparator) { 215 return getPersistence() 216 .fetchByStructureId_Last(structureId, orderByComparator); 217 } 218 219 /** 220 * Returns the d d m structure versions before and after the current d d m structure version in the ordered set where structureId = ?. 221 * 222 * @param structureVersionId the primary key of the current d d m structure version 223 * @param structureId the structure ID 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @return the previous, current, and next d d m structure version 226 * @throws NoSuchStructureVersionException if a d d m structure version with the primary key could not be found 227 */ 228 public static DDMStructureVersion[] findByStructureId_PrevAndNext( 229 long structureVersionId, long structureId, 230 OrderByComparator<DDMStructureVersion> orderByComparator) 231 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 232 return getPersistence() 233 .findByStructureId_PrevAndNext(structureVersionId, 234 structureId, orderByComparator); 235 } 236 237 /** 238 * Removes all the d d m structure versions where structureId = ? from the database. 239 * 240 * @param structureId the structure ID 241 */ 242 public static void removeByStructureId(long structureId) { 243 getPersistence().removeByStructureId(structureId); 244 } 245 246 /** 247 * Returns the number of d d m structure versions where structureId = ?. 248 * 249 * @param structureId the structure ID 250 * @return the number of matching d d m structure versions 251 */ 252 public static int countByStructureId(long structureId) { 253 return getPersistence().countByStructureId(structureId); 254 } 255 256 /** 257 * Returns the d d m structure version where structureId = ? and version = ? or throws a {@link NoSuchStructureVersionException} if it could not be found. 258 * 259 * @param structureId the structure ID 260 * @param version the version 261 * @return the matching d d m structure version 262 * @throws NoSuchStructureVersionException if a matching d d m structure version could not be found 263 */ 264 public static DDMStructureVersion findByS_V(long structureId, 265 java.lang.String version) 266 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 267 return getPersistence().findByS_V(structureId, version); 268 } 269 270 /** 271 * Returns the d d m structure version where structureId = ? and version = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 272 * 273 * @param structureId the structure ID 274 * @param version the version 275 * @return the matching d d m structure version, or <code>null</code> if a matching d d m structure version could not be found 276 */ 277 public static DDMStructureVersion fetchByS_V(long structureId, 278 java.lang.String version) { 279 return getPersistence().fetchByS_V(structureId, version); 280 } 281 282 /** 283 * Returns the d d m structure version where structureId = ? and version = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 284 * 285 * @param structureId the structure ID 286 * @param version the version 287 * @param retrieveFromCache whether to use the finder cache 288 * @return the matching d d m structure version, or <code>null</code> if a matching d d m structure version could not be found 289 */ 290 public static DDMStructureVersion fetchByS_V(long structureId, 291 java.lang.String version, boolean retrieveFromCache) { 292 return getPersistence() 293 .fetchByS_V(structureId, version, retrieveFromCache); 294 } 295 296 /** 297 * Removes the d d m structure version where structureId = ? and version = ? from the database. 298 * 299 * @param structureId the structure ID 300 * @param version the version 301 * @return the d d m structure version that was removed 302 */ 303 public static DDMStructureVersion removeByS_V(long structureId, 304 java.lang.String version) 305 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 306 return getPersistence().removeByS_V(structureId, version); 307 } 308 309 /** 310 * Returns the number of d d m structure versions where structureId = ? and version = ?. 311 * 312 * @param structureId the structure ID 313 * @param version the version 314 * @return the number of matching d d m structure versions 315 */ 316 public static int countByS_V(long structureId, java.lang.String version) { 317 return getPersistence().countByS_V(structureId, version); 318 } 319 320 /** 321 * Returns all the d d m structure versions where structureId = ? and status = ?. 322 * 323 * @param structureId the structure ID 324 * @param status the status 325 * @return the matching d d m structure versions 326 */ 327 public static List<DDMStructureVersion> findByS_S(long structureId, 328 int status) { 329 return getPersistence().findByS_S(structureId, status); 330 } 331 332 /** 333 * Returns a range of all the d d m structure versions where structureId = ? and status = ?. 334 * 335 * <p> 336 * 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 DDMStructureVersionModelImpl}. 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. 337 * </p> 338 * 339 * @param structureId the structure ID 340 * @param status the status 341 * @param start the lower bound of the range of d d m structure versions 342 * @param end the upper bound of the range of d d m structure versions (not inclusive) 343 * @return the range of matching d d m structure versions 344 */ 345 public static List<DDMStructureVersion> findByS_S(long structureId, 346 int status, int start, int end) { 347 return getPersistence().findByS_S(structureId, status, start, end); 348 } 349 350 /** 351 * Returns an ordered range of all the d d m structure versions where structureId = ? and status = ?. 352 * 353 * <p> 354 * 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 DDMStructureVersionModelImpl}. 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. 355 * </p> 356 * 357 * @param structureId the structure ID 358 * @param status the status 359 * @param start the lower bound of the range of d d m structure versions 360 * @param end the upper bound of the range of d d m structure versions (not inclusive) 361 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 362 * @return the ordered range of matching d d m structure versions 363 */ 364 public static List<DDMStructureVersion> findByS_S(long structureId, 365 int status, int start, int end, 366 OrderByComparator<DDMStructureVersion> orderByComparator) { 367 return getPersistence() 368 .findByS_S(structureId, status, start, end, orderByComparator); 369 } 370 371 /** 372 * Returns the first d d m structure version in the ordered set where structureId = ? and status = ?. 373 * 374 * @param structureId the structure ID 375 * @param status the status 376 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 377 * @return the first matching d d m structure version 378 * @throws NoSuchStructureVersionException if a matching d d m structure version could not be found 379 */ 380 public static DDMStructureVersion findByS_S_First(long structureId, 381 int status, OrderByComparator<DDMStructureVersion> orderByComparator) 382 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 383 return getPersistence() 384 .findByS_S_First(structureId, status, orderByComparator); 385 } 386 387 /** 388 * Returns the first d d m structure version in the ordered set where structureId = ? and status = ?. 389 * 390 * @param structureId the structure ID 391 * @param status the status 392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 393 * @return the first matching d d m structure version, or <code>null</code> if a matching d d m structure version could not be found 394 */ 395 public static DDMStructureVersion fetchByS_S_First(long structureId, 396 int status, OrderByComparator<DDMStructureVersion> orderByComparator) { 397 return getPersistence() 398 .fetchByS_S_First(structureId, status, orderByComparator); 399 } 400 401 /** 402 * Returns the last d d m structure version in the ordered set where structureId = ? and status = ?. 403 * 404 * @param structureId the structure ID 405 * @param status the status 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the last matching d d m structure version 408 * @throws NoSuchStructureVersionException if a matching d d m structure version could not be found 409 */ 410 public static DDMStructureVersion findByS_S_Last(long structureId, 411 int status, OrderByComparator<DDMStructureVersion> orderByComparator) 412 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 413 return getPersistence() 414 .findByS_S_Last(structureId, status, orderByComparator); 415 } 416 417 /** 418 * Returns the last d d m structure version in the ordered set where structureId = ? and status = ?. 419 * 420 * @param structureId the structure ID 421 * @param status the status 422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 423 * @return the last matching d d m structure version, or <code>null</code> if a matching d d m structure version could not be found 424 */ 425 public static DDMStructureVersion fetchByS_S_Last(long structureId, 426 int status, OrderByComparator<DDMStructureVersion> orderByComparator) { 427 return getPersistence() 428 .fetchByS_S_Last(structureId, status, orderByComparator); 429 } 430 431 /** 432 * Returns the d d m structure versions before and after the current d d m structure version in the ordered set where structureId = ? and status = ?. 433 * 434 * @param structureVersionId the primary key of the current d d m structure version 435 * @param structureId the structure ID 436 * @param status the status 437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 438 * @return the previous, current, and next d d m structure version 439 * @throws NoSuchStructureVersionException if a d d m structure version with the primary key could not be found 440 */ 441 public static DDMStructureVersion[] findByS_S_PrevAndNext( 442 long structureVersionId, long structureId, int status, 443 OrderByComparator<DDMStructureVersion> orderByComparator) 444 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 445 return getPersistence() 446 .findByS_S_PrevAndNext(structureVersionId, structureId, 447 status, orderByComparator); 448 } 449 450 /** 451 * Removes all the d d m structure versions where structureId = ? and status = ? from the database. 452 * 453 * @param structureId the structure ID 454 * @param status the status 455 */ 456 public static void removeByS_S(long structureId, int status) { 457 getPersistence().removeByS_S(structureId, status); 458 } 459 460 /** 461 * Returns the number of d d m structure versions where structureId = ? and status = ?. 462 * 463 * @param structureId the structure ID 464 * @param status the status 465 * @return the number of matching d d m structure versions 466 */ 467 public static int countByS_S(long structureId, int status) { 468 return getPersistence().countByS_S(structureId, status); 469 } 470 471 /** 472 * Caches the d d m structure version in the entity cache if it is enabled. 473 * 474 * @param ddmStructureVersion the d d m structure version 475 */ 476 public static void cacheResult(DDMStructureVersion ddmStructureVersion) { 477 getPersistence().cacheResult(ddmStructureVersion); 478 } 479 480 /** 481 * Caches the d d m structure versions in the entity cache if it is enabled. 482 * 483 * @param ddmStructureVersions the d d m structure versions 484 */ 485 public static void cacheResult( 486 List<DDMStructureVersion> ddmStructureVersions) { 487 getPersistence().cacheResult(ddmStructureVersions); 488 } 489 490 /** 491 * Creates a new d d m structure version with the primary key. Does not add the d d m structure version to the database. 492 * 493 * @param structureVersionId the primary key for the new d d m structure version 494 * @return the new d d m structure version 495 */ 496 public static DDMStructureVersion create(long structureVersionId) { 497 return getPersistence().create(structureVersionId); 498 } 499 500 /** 501 * Removes the d d m structure version with the primary key from the database. Also notifies the appropriate model listeners. 502 * 503 * @param structureVersionId the primary key of the d d m structure version 504 * @return the d d m structure version that was removed 505 * @throws NoSuchStructureVersionException if a d d m structure version with the primary key could not be found 506 */ 507 public static DDMStructureVersion remove(long structureVersionId) 508 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 509 return getPersistence().remove(structureVersionId); 510 } 511 512 public static DDMStructureVersion updateImpl( 513 DDMStructureVersion ddmStructureVersion) { 514 return getPersistence().updateImpl(ddmStructureVersion); 515 } 516 517 /** 518 * Returns the d d m structure version with the primary key or throws a {@link NoSuchStructureVersionException} if it could not be found. 519 * 520 * @param structureVersionId the primary key of the d d m structure version 521 * @return the d d m structure version 522 * @throws NoSuchStructureVersionException if a d d m structure version with the primary key could not be found 523 */ 524 public static DDMStructureVersion findByPrimaryKey(long structureVersionId) 525 throws com.liferay.portlet.dynamicdatamapping.NoSuchStructureVersionException { 526 return getPersistence().findByPrimaryKey(structureVersionId); 527 } 528 529 /** 530 * Returns the d d m structure version with the primary key or returns <code>null</code> if it could not be found. 531 * 532 * @param structureVersionId the primary key of the d d m structure version 533 * @return the d d m structure version, or <code>null</code> if a d d m structure version with the primary key could not be found 534 */ 535 public static DDMStructureVersion fetchByPrimaryKey(long structureVersionId) { 536 return getPersistence().fetchByPrimaryKey(structureVersionId); 537 } 538 539 public static java.util.Map<java.io.Serializable, DDMStructureVersion> fetchByPrimaryKeys( 540 java.util.Set<java.io.Serializable> primaryKeys) { 541 return getPersistence().fetchByPrimaryKeys(primaryKeys); 542 } 543 544 /** 545 * Returns all the d d m structure versions. 546 * 547 * @return the d d m structure versions 548 */ 549 public static List<DDMStructureVersion> findAll() { 550 return getPersistence().findAll(); 551 } 552 553 /** 554 * Returns a range of all the d d m structure versions. 555 * 556 * <p> 557 * 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 DDMStructureVersionModelImpl}. 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. 558 * </p> 559 * 560 * @param start the lower bound of the range of d d m structure versions 561 * @param end the upper bound of the range of d d m structure versions (not inclusive) 562 * @return the range of d d m structure versions 563 */ 564 public static List<DDMStructureVersion> findAll(int start, int end) { 565 return getPersistence().findAll(start, end); 566 } 567 568 /** 569 * Returns an ordered range of all the d d m structure versions. 570 * 571 * <p> 572 * 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 DDMStructureVersionModelImpl}. 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. 573 * </p> 574 * 575 * @param start the lower bound of the range of d d m structure versions 576 * @param end the upper bound of the range of d d m structure versions (not inclusive) 577 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 578 * @return the ordered range of d d m structure versions 579 */ 580 public static List<DDMStructureVersion> findAll(int start, int end, 581 OrderByComparator<DDMStructureVersion> orderByComparator) { 582 return getPersistence().findAll(start, end, orderByComparator); 583 } 584 585 /** 586 * Removes all the d d m structure versions from the database. 587 */ 588 public static void removeAll() { 589 getPersistence().removeAll(); 590 } 591 592 /** 593 * Returns the number of d d m structure versions. 594 * 595 * @return the number of d d m structure versions 596 */ 597 public static int countAll() { 598 return getPersistence().countAll(); 599 } 600 601 public static DDMStructureVersionPersistence getPersistence() { 602 if (_persistence == null) { 603 _persistence = (DDMStructureVersionPersistence)PortalBeanLocatorUtil.locate(DDMStructureVersionPersistence.class.getName()); 604 605 ReferenceRegistry.registerReference(DDMStructureVersionUtil.class, 606 "_persistence"); 607 } 608 609 return _persistence; 610 } 611 612 /** 613 * @deprecated As of 6.2.0 614 */ 615 @Deprecated 616 public void setPersistence(DDMStructureVersionPersistence persistence) { 617 } 618 619 private static DDMStructureVersionPersistence _persistence; 620 }