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.portal.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.model.LayoutSet; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the layout set service. This utility wraps {@link com.liferay.portal.service.persistence.impl.LayoutSetPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see LayoutSetPersistence 037 * @see com.liferay.portal.service.persistence.impl.LayoutSetPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class LayoutSetUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(LayoutSet layoutSet) { 059 getPersistence().clearCache(layoutSet); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<LayoutSet> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<LayoutSet> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<LayoutSet> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<LayoutSet> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static LayoutSet update(LayoutSet layoutSet) { 100 return getPersistence().update(layoutSet); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static LayoutSet update(LayoutSet layoutSet, 107 ServiceContext serviceContext) { 108 return getPersistence().update(layoutSet, serviceContext); 109 } 110 111 /** 112 * Returns all the layout sets where groupId = ?. 113 * 114 * @param groupId the group ID 115 * @return the matching layout sets 116 */ 117 public static List<LayoutSet> findByGroupId(long groupId) { 118 return getPersistence().findByGroupId(groupId); 119 } 120 121 /** 122 * Returns a range of all the layout sets where groupId = ?. 123 * 124 * <p> 125 * 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 LayoutSetModelImpl}. 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. 126 * </p> 127 * 128 * @param groupId the group ID 129 * @param start the lower bound of the range of layout sets 130 * @param end the upper bound of the range of layout sets (not inclusive) 131 * @return the range of matching layout sets 132 */ 133 public static List<LayoutSet> findByGroupId(long groupId, int start, int end) { 134 return getPersistence().findByGroupId(groupId, start, end); 135 } 136 137 /** 138 * Returns an ordered range of all the layout sets where groupId = ?. 139 * 140 * <p> 141 * 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 LayoutSetModelImpl}. 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. 142 * </p> 143 * 144 * @param groupId the group ID 145 * @param start the lower bound of the range of layout sets 146 * @param end the upper bound of the range of layout sets (not inclusive) 147 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 148 * @return the ordered range of matching layout sets 149 */ 150 public static List<LayoutSet> findByGroupId(long groupId, int start, 151 int end, OrderByComparator<LayoutSet> orderByComparator) { 152 return getPersistence() 153 .findByGroupId(groupId, start, end, orderByComparator); 154 } 155 156 /** 157 * Returns the first layout set in the ordered set where groupId = ?. 158 * 159 * @param groupId the group ID 160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 161 * @return the first matching layout set 162 * @throws NoSuchLayoutSetException if a matching layout set could not be found 163 */ 164 public static LayoutSet findByGroupId_First(long groupId, 165 OrderByComparator<LayoutSet> orderByComparator) 166 throws com.liferay.portal.NoSuchLayoutSetException { 167 return getPersistence().findByGroupId_First(groupId, orderByComparator); 168 } 169 170 /** 171 * Returns the first layout set in the ordered set where groupId = ?. 172 * 173 * @param groupId the group ID 174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 175 * @return the first matching layout set, or <code>null</code> if a matching layout set could not be found 176 */ 177 public static LayoutSet fetchByGroupId_First(long groupId, 178 OrderByComparator<LayoutSet> orderByComparator) { 179 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 180 } 181 182 /** 183 * Returns the last layout set in the ordered set where groupId = ?. 184 * 185 * @param groupId the group ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the last matching layout set 188 * @throws NoSuchLayoutSetException if a matching layout set could not be found 189 */ 190 public static LayoutSet findByGroupId_Last(long groupId, 191 OrderByComparator<LayoutSet> orderByComparator) 192 throws com.liferay.portal.NoSuchLayoutSetException { 193 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 194 } 195 196 /** 197 * Returns the last layout set in the ordered set where groupId = ?. 198 * 199 * @param groupId the group ID 200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 201 * @return the last matching layout set, or <code>null</code> if a matching layout set could not be found 202 */ 203 public static LayoutSet fetchByGroupId_Last(long groupId, 204 OrderByComparator<LayoutSet> orderByComparator) { 205 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 206 } 207 208 /** 209 * Returns the layout sets before and after the current layout set in the ordered set where groupId = ?. 210 * 211 * @param layoutSetId the primary key of the current layout set 212 * @param groupId the group ID 213 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 214 * @return the previous, current, and next layout set 215 * @throws NoSuchLayoutSetException if a layout set with the primary key could not be found 216 */ 217 public static LayoutSet[] findByGroupId_PrevAndNext(long layoutSetId, 218 long groupId, OrderByComparator<LayoutSet> orderByComparator) 219 throws com.liferay.portal.NoSuchLayoutSetException { 220 return getPersistence() 221 .findByGroupId_PrevAndNext(layoutSetId, groupId, 222 orderByComparator); 223 } 224 225 /** 226 * Removes all the layout sets where groupId = ? from the database. 227 * 228 * @param groupId the group ID 229 */ 230 public static void removeByGroupId(long groupId) { 231 getPersistence().removeByGroupId(groupId); 232 } 233 234 /** 235 * Returns the number of layout sets where groupId = ?. 236 * 237 * @param groupId the group ID 238 * @return the number of matching layout sets 239 */ 240 public static int countByGroupId(long groupId) { 241 return getPersistence().countByGroupId(groupId); 242 } 243 244 /** 245 * Returns all the layout sets where layoutSetPrototypeUuid = ?. 246 * 247 * @param layoutSetPrototypeUuid the layout set prototype uuid 248 * @return the matching layout sets 249 */ 250 public static List<LayoutSet> findByLayoutSetPrototypeUuid( 251 java.lang.String layoutSetPrototypeUuid) { 252 return getPersistence() 253 .findByLayoutSetPrototypeUuid(layoutSetPrototypeUuid); 254 } 255 256 /** 257 * Returns a range of all the layout sets where layoutSetPrototypeUuid = ?. 258 * 259 * <p> 260 * 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 LayoutSetModelImpl}. 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. 261 * </p> 262 * 263 * @param layoutSetPrototypeUuid the layout set prototype uuid 264 * @param start the lower bound of the range of layout sets 265 * @param end the upper bound of the range of layout sets (not inclusive) 266 * @return the range of matching layout sets 267 */ 268 public static List<LayoutSet> findByLayoutSetPrototypeUuid( 269 java.lang.String layoutSetPrototypeUuid, int start, int end) { 270 return getPersistence() 271 .findByLayoutSetPrototypeUuid(layoutSetPrototypeUuid, start, 272 end); 273 } 274 275 /** 276 * Returns an ordered range of all the layout sets where layoutSetPrototypeUuid = ?. 277 * 278 * <p> 279 * 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 LayoutSetModelImpl}. 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. 280 * </p> 281 * 282 * @param layoutSetPrototypeUuid the layout set prototype uuid 283 * @param start the lower bound of the range of layout sets 284 * @param end the upper bound of the range of layout sets (not inclusive) 285 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 286 * @return the ordered range of matching layout sets 287 */ 288 public static List<LayoutSet> findByLayoutSetPrototypeUuid( 289 java.lang.String layoutSetPrototypeUuid, int start, int end, 290 OrderByComparator<LayoutSet> orderByComparator) { 291 return getPersistence() 292 .findByLayoutSetPrototypeUuid(layoutSetPrototypeUuid, start, 293 end, orderByComparator); 294 } 295 296 /** 297 * Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ?. 298 * 299 * @param layoutSetPrototypeUuid the layout set prototype uuid 300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 301 * @return the first matching layout set 302 * @throws NoSuchLayoutSetException if a matching layout set could not be found 303 */ 304 public static LayoutSet findByLayoutSetPrototypeUuid_First( 305 java.lang.String layoutSetPrototypeUuid, 306 OrderByComparator<LayoutSet> orderByComparator) 307 throws com.liferay.portal.NoSuchLayoutSetException { 308 return getPersistence() 309 .findByLayoutSetPrototypeUuid_First(layoutSetPrototypeUuid, 310 orderByComparator); 311 } 312 313 /** 314 * Returns the first layout set in the ordered set where layoutSetPrototypeUuid = ?. 315 * 316 * @param layoutSetPrototypeUuid the layout set prototype uuid 317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 318 * @return the first matching layout set, or <code>null</code> if a matching layout set could not be found 319 */ 320 public static LayoutSet fetchByLayoutSetPrototypeUuid_First( 321 java.lang.String layoutSetPrototypeUuid, 322 OrderByComparator<LayoutSet> orderByComparator) { 323 return getPersistence() 324 .fetchByLayoutSetPrototypeUuid_First(layoutSetPrototypeUuid, 325 orderByComparator); 326 } 327 328 /** 329 * Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ?. 330 * 331 * @param layoutSetPrototypeUuid the layout set prototype uuid 332 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 333 * @return the last matching layout set 334 * @throws NoSuchLayoutSetException if a matching layout set could not be found 335 */ 336 public static LayoutSet findByLayoutSetPrototypeUuid_Last( 337 java.lang.String layoutSetPrototypeUuid, 338 OrderByComparator<LayoutSet> orderByComparator) 339 throws com.liferay.portal.NoSuchLayoutSetException { 340 return getPersistence() 341 .findByLayoutSetPrototypeUuid_Last(layoutSetPrototypeUuid, 342 orderByComparator); 343 } 344 345 /** 346 * Returns the last layout set in the ordered set where layoutSetPrototypeUuid = ?. 347 * 348 * @param layoutSetPrototypeUuid the layout set prototype uuid 349 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 350 * @return the last matching layout set, or <code>null</code> if a matching layout set could not be found 351 */ 352 public static LayoutSet fetchByLayoutSetPrototypeUuid_Last( 353 java.lang.String layoutSetPrototypeUuid, 354 OrderByComparator<LayoutSet> orderByComparator) { 355 return getPersistence() 356 .fetchByLayoutSetPrototypeUuid_Last(layoutSetPrototypeUuid, 357 orderByComparator); 358 } 359 360 /** 361 * Returns the layout sets before and after the current layout set in the ordered set where layoutSetPrototypeUuid = ?. 362 * 363 * @param layoutSetId the primary key of the current layout set 364 * @param layoutSetPrototypeUuid the layout set prototype uuid 365 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 366 * @return the previous, current, and next layout set 367 * @throws NoSuchLayoutSetException if a layout set with the primary key could not be found 368 */ 369 public static LayoutSet[] findByLayoutSetPrototypeUuid_PrevAndNext( 370 long layoutSetId, java.lang.String layoutSetPrototypeUuid, 371 OrderByComparator<LayoutSet> orderByComparator) 372 throws com.liferay.portal.NoSuchLayoutSetException { 373 return getPersistence() 374 .findByLayoutSetPrototypeUuid_PrevAndNext(layoutSetId, 375 layoutSetPrototypeUuid, orderByComparator); 376 } 377 378 /** 379 * Removes all the layout sets where layoutSetPrototypeUuid = ? from the database. 380 * 381 * @param layoutSetPrototypeUuid the layout set prototype uuid 382 */ 383 public static void removeByLayoutSetPrototypeUuid( 384 java.lang.String layoutSetPrototypeUuid) { 385 getPersistence().removeByLayoutSetPrototypeUuid(layoutSetPrototypeUuid); 386 } 387 388 /** 389 * Returns the number of layout sets where layoutSetPrototypeUuid = ?. 390 * 391 * @param layoutSetPrototypeUuid the layout set prototype uuid 392 * @return the number of matching layout sets 393 */ 394 public static int countByLayoutSetPrototypeUuid( 395 java.lang.String layoutSetPrototypeUuid) { 396 return getPersistence() 397 .countByLayoutSetPrototypeUuid(layoutSetPrototypeUuid); 398 } 399 400 /** 401 * Returns the layout set where groupId = ? and privateLayout = ? or throws a {@link NoSuchLayoutSetException} if it could not be found. 402 * 403 * @param groupId the group ID 404 * @param privateLayout the private layout 405 * @return the matching layout set 406 * @throws NoSuchLayoutSetException if a matching layout set could not be found 407 */ 408 public static LayoutSet findByG_P(long groupId, boolean privateLayout) 409 throws com.liferay.portal.NoSuchLayoutSetException { 410 return getPersistence().findByG_P(groupId, privateLayout); 411 } 412 413 /** 414 * Returns the layout set where groupId = ? and privateLayout = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 415 * 416 * @param groupId the group ID 417 * @param privateLayout the private layout 418 * @return the matching layout set, or <code>null</code> if a matching layout set could not be found 419 */ 420 public static LayoutSet fetchByG_P(long groupId, boolean privateLayout) { 421 return getPersistence().fetchByG_P(groupId, privateLayout); 422 } 423 424 /** 425 * Returns the layout set where groupId = ? and privateLayout = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 426 * 427 * @param groupId the group ID 428 * @param privateLayout the private layout 429 * @param retrieveFromCache whether to use the finder cache 430 * @return the matching layout set, or <code>null</code> if a matching layout set could not be found 431 */ 432 public static LayoutSet fetchByG_P(long groupId, boolean privateLayout, 433 boolean retrieveFromCache) { 434 return getPersistence() 435 .fetchByG_P(groupId, privateLayout, retrieveFromCache); 436 } 437 438 /** 439 * Removes the layout set where groupId = ? and privateLayout = ? from the database. 440 * 441 * @param groupId the group ID 442 * @param privateLayout the private layout 443 * @return the layout set that was removed 444 */ 445 public static LayoutSet removeByG_P(long groupId, boolean privateLayout) 446 throws com.liferay.portal.NoSuchLayoutSetException { 447 return getPersistence().removeByG_P(groupId, privateLayout); 448 } 449 450 /** 451 * Returns the number of layout sets where groupId = ? and privateLayout = ?. 452 * 453 * @param groupId the group ID 454 * @param privateLayout the private layout 455 * @return the number of matching layout sets 456 */ 457 public static int countByG_P(long groupId, boolean privateLayout) { 458 return getPersistence().countByG_P(groupId, privateLayout); 459 } 460 461 /** 462 * Caches the layout set in the entity cache if it is enabled. 463 * 464 * @param layoutSet the layout set 465 */ 466 public static void cacheResult(LayoutSet layoutSet) { 467 getPersistence().cacheResult(layoutSet); 468 } 469 470 /** 471 * Caches the layout sets in the entity cache if it is enabled. 472 * 473 * @param layoutSets the layout sets 474 */ 475 public static void cacheResult(List<LayoutSet> layoutSets) { 476 getPersistence().cacheResult(layoutSets); 477 } 478 479 /** 480 * Creates a new layout set with the primary key. Does not add the layout set to the database. 481 * 482 * @param layoutSetId the primary key for the new layout set 483 * @return the new layout set 484 */ 485 public static LayoutSet create(long layoutSetId) { 486 return getPersistence().create(layoutSetId); 487 } 488 489 /** 490 * Removes the layout set with the primary key from the database. Also notifies the appropriate model listeners. 491 * 492 * @param layoutSetId the primary key of the layout set 493 * @return the layout set that was removed 494 * @throws NoSuchLayoutSetException if a layout set with the primary key could not be found 495 */ 496 public static LayoutSet remove(long layoutSetId) 497 throws com.liferay.portal.NoSuchLayoutSetException { 498 return getPersistence().remove(layoutSetId); 499 } 500 501 public static LayoutSet updateImpl(LayoutSet layoutSet) { 502 return getPersistence().updateImpl(layoutSet); 503 } 504 505 /** 506 * Returns the layout set with the primary key or throws a {@link NoSuchLayoutSetException} if it could not be found. 507 * 508 * @param layoutSetId the primary key of the layout set 509 * @return the layout set 510 * @throws NoSuchLayoutSetException if a layout set with the primary key could not be found 511 */ 512 public static LayoutSet findByPrimaryKey(long layoutSetId) 513 throws com.liferay.portal.NoSuchLayoutSetException { 514 return getPersistence().findByPrimaryKey(layoutSetId); 515 } 516 517 /** 518 * Returns the layout set with the primary key or returns <code>null</code> if it could not be found. 519 * 520 * @param layoutSetId the primary key of the layout set 521 * @return the layout set, or <code>null</code> if a layout set with the primary key could not be found 522 */ 523 public static LayoutSet fetchByPrimaryKey(long layoutSetId) { 524 return getPersistence().fetchByPrimaryKey(layoutSetId); 525 } 526 527 public static java.util.Map<java.io.Serializable, LayoutSet> fetchByPrimaryKeys( 528 java.util.Set<java.io.Serializable> primaryKeys) { 529 return getPersistence().fetchByPrimaryKeys(primaryKeys); 530 } 531 532 /** 533 * Returns all the layout sets. 534 * 535 * @return the layout sets 536 */ 537 public static List<LayoutSet> findAll() { 538 return getPersistence().findAll(); 539 } 540 541 /** 542 * Returns a range of all the layout sets. 543 * 544 * <p> 545 * 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 LayoutSetModelImpl}. 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. 546 * </p> 547 * 548 * @param start the lower bound of the range of layout sets 549 * @param end the upper bound of the range of layout sets (not inclusive) 550 * @return the range of layout sets 551 */ 552 public static List<LayoutSet> findAll(int start, int end) { 553 return getPersistence().findAll(start, end); 554 } 555 556 /** 557 * Returns an ordered range of all the layout sets. 558 * 559 * <p> 560 * 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 LayoutSetModelImpl}. 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. 561 * </p> 562 * 563 * @param start the lower bound of the range of layout sets 564 * @param end the upper bound of the range of layout sets (not inclusive) 565 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 566 * @return the ordered range of layout sets 567 */ 568 public static List<LayoutSet> findAll(int start, int end, 569 OrderByComparator<LayoutSet> orderByComparator) { 570 return getPersistence().findAll(start, end, orderByComparator); 571 } 572 573 /** 574 * Removes all the layout sets from the database. 575 */ 576 public static void removeAll() { 577 getPersistence().removeAll(); 578 } 579 580 /** 581 * Returns the number of layout sets. 582 * 583 * @return the number of layout sets 584 */ 585 public static int countAll() { 586 return getPersistence().countAll(); 587 } 588 589 public static LayoutSetPersistence getPersistence() { 590 if (_persistence == null) { 591 _persistence = (LayoutSetPersistence)PortalBeanLocatorUtil.locate(LayoutSetPersistence.class.getName()); 592 593 ReferenceRegistry.registerReference(LayoutSetUtil.class, 594 "_persistence"); 595 } 596 597 return _persistence; 598 } 599 600 /** 601 * @deprecated As of 6.2.0 602 */ 603 @Deprecated 604 public void setPersistence(LayoutSetPersistence persistence) { 605 } 606 607 private static LayoutSetPersistence _persistence; 608 }